#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <float.h>
#include <math.h>
#include <errno.h>
#include <sys/types.h>
#include <time.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <strings.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>

Classes
union	soap_double_nan

struct	Namespace

struct	soap_nlist

struct	soap_bhead

struct	soap_blist

struct	soap_plist

struct	soap_pblk

struct	soap_clist

struct	soap_attribute

struct	soap_cookie

struct	soap_dime

struct	soap_mime

struct	soap_multipart

struct	soap_xlist

struct	soap_dom_attribute

struct	soap_dom_element

struct	soap

struct	soap_code_map

struct	soap_flist

struct	soap_ilist

struct	soap_plugin

Macros
#define	GSOAP_VERSION 208105

#define	_THREAD_SAFE

#define	_REENTRANT

#define	SOAP_FMAC1

#define	SOAP_FMAC2

#define	SOAP_FMAC3

#define	SOAP_FMAC3S SOAP_FMAC3

#define	SOAP_FMAC4

#define	SOAP_FMAC4S SOAP_FMAC4

#define	SOAP_FMAC5

#define	SOAP_FMAC6

#define	SOAP_CMAC

#define	SOAP_NMAC

#define	SOAP_SOURCE_STAMP(str)

#define	STDSOAP_H

#define	SOAP_XSTRINGIFY(s) SOAP_STRINGIFY(s)

#define	SOAP_STRINGIFY(s) #s

#define	WITH_NO_C_LOCALE /* turn locale support off by default */

#define	HAVE_SNPRINTF

#define	HAVE_STRRCHR

#define	HAVE_STRTOD

#define	HAVE_SSCANF

#define	HAVE_STRTOL

#define	HAVE_STRTOUL

#define	HAVE_STRTOLL

#define	HAVE_STRTOULL

#define	HAVE_GETTIMEOFDAY

#define	HAVE_RAND_R

#define	HAVE_GETHOSTBYNAME_R

#define	HAVE_GMTIME_R

#define	HAVE_ASCTIME_R

#define	HAVE_LOCALTIME_R

#define	HAVE_STRERROR_R

#define	HAVE_LOCALE_H

#define	WITH_FAST

#define	WITH_CDATA

#define	WITH_NOEMPTYSTRUCT

#define	SOAP_PURE_VIRTUAL

#define	SOAP_PURE_VIRTUAL_COPY

#define	SOAP_BINARY_BUFLEN (128)

#define	SOAP_WINSOCKINT size_t

#define	SOAP_STRCMP strcmp /* case sensitive XML element/attribute names */

#define	SOAP_SOCKLEN_T socklen_t

#define	SOAP_FUNC_R_ERR (NULL)

#define	SOAP_SOCKET int

#define	soap_closesocket(n) close(n)

#define	SOAP_INVALID_SOCKET ((SOAP_SOCKET)-1)

#define	soap_valid_socket(sk) ((sk) != SOAP_INVALID_SOCKET)

#define	SOAP_SHUT_WR (1)

#define	SOAP_SHUT_RDWR (2)

#define	SOAP_GAI_STRERROR gai_strerror

#define	FD_SETSIZE (1024)

#define	SOAP_CHK_EOF (soap->error ? soap->error : SOAP_EOF)

#define	LONG64 long long

#define	ULONG64 unsigned LONG64

#define	SOAP_LONG_FORMAT "%lld" /* printf format for 64 bit long long ints */

#define	SOAP_ULONG_FORMAT "%llu" /* printf format for unsigned 64 bit long long ints */

#define	soap_int32 int32_t

#define	SOAP_ERANGE (34)

#define	SOAP_EINTR EINTR

#define	SOAP_EAGAIN EAGAIN

#define	SOAP_EADDRINUSE EADDRINUSE

#define	SOAP_ECONNREFUSED ECONNREFUSED

#define	SOAP_EWOULDBLOCK EWOULDBLOCK

#define	SOAP_EINPROGRESS EINPROGRESS

#define	soap_errno errno

#define	soap_socket_errno errno

#define	soap_reset_errno (errno = ENOENT)

#define	SOAP_BUFLEN (65536) /* buffer length for socket packets, so don't make this too small */

#define	SOAP_LABLEN (256) /* initial look-aside buffer length */

#define	SOAP_PTRBLK (32) /* block allocation for pointer hash table chains */

#define	SOAP_PTRHASH (4096) /* size of pointer analysis hash table (must be power of 2) */

#define	SOAP_IDHASH (1999) /* 1999, 8191: prime size of hash table for parsed id/ref */

#define	SOAP_BLKLEN (256) /* to collect long strings and XML attributes */

#define	SOAP_TAGLEN (1024) /* maximum length of XML element tag/attribute name or host/path name + 1 */

#define	SOAP_HDRLEN (8192) /* maximum length of HTTP header line (must be >=4096 to read cookies) */

#define	SOAP_TMPLEN (2048) /* maximum length of msgbuf and tmpbuf short message buffers, must be >=1024 */

#define	SOAP_MAXDIMS (16) /* maximum array dimensions (array nestings) must be less than 64 to protect soap->tmpbuf */

#define	SOAP_MAXPTRS (4) /* maximum depth + 1 of id-ref deserialized pointer types (int* has depth 0, int*** has depth 2) */

#define	SOAP_MAXALLOCSIZE (0) /* max size that malloc() can handle, zero for no limit */

#define	SOAP_MAXLOGS (3) /* max number of debug logs per struct soap environment */

#define	SOAP_INDEX_RECV (0)

#define	SOAP_INDEX_SENT (1)

#define	SOAP_INDEX_TEST (2)

#define	SOAP_MULTIREFTAG "id"

#define	SOAP_BASEREFNAME "_"

#define	SOAP_MAXEINTR (10)

#define	SOAP_MAXKEEPALIVE (100)

#define	SOAP_MAXARRAYSIZE (100000)

#define	SOAP_MAXDIMESIZE (81048576) / 8 MB */

#define	SOAP_MAXINFLATESIZE (11048576) / 1 MB */

#define	SOAP_MINDEFLATERATIO (1.0/1032.0) /* ratio of deflated/inflated */

#define	SOAP_MAXLEVEL (10000)

#define	SOAP_MAXLENGTH (0)

#define	SOAP_MAXOCCURS (100000)

#define	FLT_NAN (soap_double_nan.fv)

#define	FLT_PINFTY (3.40282347e+38F)

#define	FLT_NINFTY (-FLT_PINFTY)

#define	DBL_NAN (soap_double_nan.dv)

#define	DBL_PINFTY (1.7976931348623157e+308)

#define	DBL_NINFTY (-DBL_PINFTY)

#define	soap_isnan(n) ((n) != (n))

#define	soap_isinf(n) (!soap_isnan(n) && soap_isnan((n) - (n)))

#define	soap_ispinfd(n) ((n) > 0 && soap_isinf(n))

#define	soap_ispinff(n) ((n) > 0 && soap_isinf(n))

#define	soap_isninfd(n) ((n) < 0 && soap_isinf(n))

#define	soap_isninff(n) ((n) < 0 && soap_isinf(n))

#define	SOAP_SNPRINTF(buf, len, num) void)snprintf((buf), (len)

#define	SOAP_SNPRINTF_SAFE(buf, len) void)snprintf((buf), (len)

#define	soap_strcpy(buf, len, src) (void)(strncpy((buf), (src), (len)), (buf)[(len) - 1] = '\0')

#define	soap_strncpy(buf, len, src, num) ((buf) == NULL \|\| ((size_t)(len) > (size_t)(num) ? (strncpy((buf), (src), (num)), (buf)[(size_t)(num)] = '\0') : ((buf)[0] = '\0', 1)))

#define	soap_memcpy(buf, len, src, num) ((size_t)(len) >= (size_t)(num) ? !memcpy((buf), (src), (num)) : SOAP_ERANGE)

#define	soap_memmove(buf, len, src, num) ((size_t)(len) >= (size_t)(num) ? !memmove((buf), (src), (num)) : SOAP_ERANGE)

#define	SOAP_EOF EOF

#define	SOAP_OK 0

#define	SOAP_CLI_FAULT 1

#define	SOAP_SVR_FAULT 2

#define	SOAP_TAG_MISMATCH 3

#define	SOAP_TYPE 4

#define	SOAP_SYNTAX_ERROR 5

#define	SOAP_NO_TAG 6

#define	SOAP_IOB 7

#define	SOAP_MUSTUNDERSTAND 8

#define	SOAP_NAMESPACE 9

#define	SOAP_USER_ERROR 10

#define	SOAP_FATAL_ERROR 11 /* deprecated */

#define	SOAP_FAULT 12

#define	SOAP_NO_METHOD 13

#define	SOAP_NO_DATA 14

#define	SOAP_GET_METHOD 15

#define	SOAP_PUT_METHOD 16

#define	SOAP_PATCH_METHOD 17

#define	SOAP_DEL_METHOD 18

#define	SOAP_HTTP_METHOD 19

#define	SOAP_EOM 20

#define	SOAP_MOE 21

#define	SOAP_HDR 22

#define	SOAP_NULL 23

#define	SOAP_DUPLICATE_ID 24

#define	SOAP_MISSING_ID 25

#define	SOAP_HREF 26

#define	SOAP_UDP_ERROR 27

#define	SOAP_TCP_ERROR 28

#define	SOAP_HTTP_ERROR 29

#define	SOAP_SSL_ERROR 30

#define	SOAP_ZLIB_ERROR 31

#define	SOAP_DIME_ERROR 32

#define	SOAP_DIME_HREF 33

#define	SOAP_DIME_MISMATCH 34

#define	SOAP_DIME_END 35

#define	SOAP_MIME_ERROR 36

#define	SOAP_MIME_HREF 37

#define	SOAP_MIME_END 38

#define	SOAP_VERSIONMISMATCH 39

#define	SOAP_PLUGIN_ERROR 40

#define	SOAP_DATAENCODINGUNKNOWN 41 /* unused */

#define	SOAP_REQUIRED 42

#define	SOAP_PROHIBITED 43

#define	SOAP_OCCURS 44

#define	SOAP_LENGTH 45

#define	SOAP_PATTERN 46

#define	SOAP_FD_EXCEEDED 47

#define	SOAP_UTF_ERROR 48

#define	SOAP_NTLM_ERROR 49

#define	SOAP_LEVEL 50

#define	SOAP_FIXED 51

#define	SOAP_EMPTY 52

#define	SOAP_END_TAG 53

#define	SOAP_ERR 99

#define	soap_xml_error_check(e)

#define	soap_soap_error_check(e)

#define	soap_http_error_check(e)

#define	soap_dime_error_check(e)

#define	soap_mime_error_check(e)

#define	soap_tcp_error_check(e)

#define	soap_udp_error_check(e)

#define	soap_ssl_error_check(e) ((e) == SOAP_SSL_ERROR)

#define	soap_zlib_error_check(e) ((e) == SOAP_ZLIB_ERROR)

#define	SOAP_STOP 1000 /* No HTTP response should follow after SOAP_STOP is issued */

#define	SOAP_FORM 1001 /* Request (form) data is present, no HTTP response should follow */

#define	SOAP_HTML 1002 /* Custom HTML response */

#define	SOAP_FILE 1200 /* Custom file-based response with soap::http_content and optional http status */

#define	SOAP_POST 2000 /* POST request */

#define	SOAP_POST_FILE 2001 /* Custom file-based POST request */

#define	SOAP_GET 2002 /* GET request */

#define	SOAP_PUT 2003 /* PUT request */

#define	SOAP_PATCH 2004 /* PATCH request */

#define	SOAP_DEL 2005 /* DELETE request */

#define	SOAP_HEAD 2006 /* HEAD request */

#define	SOAP_OPTIONS 2007 /* OPTIONS request */

#define	SOAP_CONNECT 2008 /* CONNECT request */

#define	SOAP_DIME_CF 0x01

#define	SOAP_DIME_ME 0x02

#define	SOAP_DIME_MB 0x04

#define	SOAP_DIME_VERSION 0x08 /* DIME version 1 */

#define	SOAP_DIME_MEDIA 0x10

#define	SOAP_DIME_ABSURI 0x20

#define	SOAP_ZLIB_NONE 0x00

#define	SOAP_ZLIB_DEFLATE 0x01

#define	SOAP_ZLIB_INFLATE 0x02

#define	SOAP_ZLIB_GZIP 0x02

#define	SOAP_IO 0x00000003 /* IO mask */

#define	SOAP_IO_FLUSH 0x00000000 /* out: flush output immediately, no buffering */

#define	SOAP_IO_BUFFER 0x00000001 /* out: buffer output in packets of size SOAP_BUFLEN */

#define	SOAP_IO_STORE 0x00000002 /* out: store entire output to determine length for transport */

#define	SOAP_IO_CHUNK 0x00000003 /* out: use HTTP chunked transfer AND buffer packets */

#define	SOAP_IO_UDP 0x00000004 /* in/out: enable UDP instead of TCP */

#define	SOAP_IO_LENGTH 0x00000008 /* out: calc message length (internal) */

#define	SOAP_IO_KEEPALIVE 0x00000010 /* out: keep connection alive */

#define	SOAP_ENC 0x00000FFF /* IO and ENC mask */

#define	SOAP_ENC_LATIN 0x00000020 /* in: accept iso-8859-1 */

#define	SOAP_ENC_PLAIN 0x00000040 /* out: plain (XML or other) body, no HTTP header */

#define	SOAP_ENC_XML 0x00000040 /* deprecated, alias for SOAP_ENC_PLAIN */

#define	SOAP_ENC_DIME 0x00000080

#define	SOAP_ENC_MIME 0x00000100

#define	SOAP_ENC_MTOM 0x00000200

#define	SOAP_ENC_ZLIB 0x00000400

#define	SOAP_ENC_SSL 0x00000800

#define	SOAP_XML_STRICT 0x00001000 /* in: strict validation */

#define	SOAP_XML_INDENT 0x00002000 /* out: emit indented XML */

#define	SOAP_XML_IGNORENS 0x00004000 /* in: ignore namespaces */

#define	SOAP_XML_DEFAULTNS 0x00008000 /* out: emit xmlns="..." */

#define	SOAP_XML_CANONICAL 0x00010000 /* out: exc-C14N exclusive canonical XML */

#define	SOAP_XML_TREE 0x00020000 /* in/out: XML tree (no id/ref) */

#define	SOAP_XML_NIL 0x00040000 /* out: all NULLs as xsi:nil */

#define	SOAP_XML_NOTYPE 0x00080000 /* out: do not add xsi:type */

#define	SOAP_DOM_TREE 0x00100000 /* see DOM manual */

#define	SOAP_DOM_NODE 0x00200000

#define	SOAP_DOM_ASIS 0x00400000

#define	SOAP_XML_CANONICAL_NA 0x00800000 /* out: (exc) C14N not QName aware */

#define	SOAP_C_NOIOB 0x01000000 /* don't fault on array index out of bounds (just ignore) */

#define	SOAP_C_UTFSTRING 0x02000000 /* (de)serialize strings with UTF8 content */

#define	SOAP_C_MBSTRING 0x04000000 /* (de)serialize strings with multi-byte content */

#define	SOAP_C_NILSTRING 0x08000000 /* serialize empty strings as nil (omitted) */

#define	SOAP_XML_DOM 0x10000000 /* enable internal DOM */

#define	SOAP_XML_GRAPH 0x20000000 /* force id-ref XML graph */

#define	SOAP_MIME_POSTCHECK 0x40000000 /* MIME flag (internal) */

#define	SOAP_SEC_WSUID 0x80000000 /* Add Body wsu:Id flag (internal) */

#define	SOAP_IO_DEFAULT SOAP_IO_FLUSH

#define	SOAP_SSL_NO_AUTHENTICATION (0x0000) /* no authentication */

#define	SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION (0x0001) /* client requires server to authenticate */

#define	SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION (0x0002) /* server requires client to authenticate */

#define	SOAP_SSL_SKIP_HOST_CHECK (0x0004) /* client skips common name check against host name */

#define	SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE (0x0008) /* allow self-signed and expired certificates and those w/o CRL */

#define	SOAP_SSL_NO_DEFAULT_CA_PATH (0x0010) /* don't use SSL_CTX_set_default_verify_paths */

#define	SOAP_SSL_RSA (0x0020) /* use RSA */

#define	SOAP_SSLv3 (0x0080) /* enable SSL v3 */

#define	SOAP_TLSv1_0 (0x0100) /* enable TLS v1.0 */

#define	SOAP_TLSv1_1 (0x0200) /* enable TLS v1.1 */

#define	SOAP_TLSv1_2 (0x0400) /* enable TLS v1.2 */

#define	SOAP_TLSv1_3 (0x0800) /* enable TLS v1.3 */

#define	SOAP_TLSv1 (SOAP_TLSv1_0 \| SOAP_TLSv1_1 \| SOAP_TLSv1_2 \| SOAP_TLSv1_3)

#define	SOAP_SSLv3_TLSv1 (SOAP_SSLv3 \| SOAP_TLSv1)

#define	SOAP_SSL_CLIENT (0x8000) /* client context flag for internal use */

#define	SOAP_SSL_DEFAULT SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION

#define	SOAP_NONE 0

#define	SOAP_INIT 1

#define	SOAP_COPY 2

#define	soap_check_state(soap) (!(soap) \|\| ((soap)->state != SOAP_INIT && (soap)->state != SOAP_COPY))

#define	SOAP_END 0

#define	SOAP_BEGIN_SEND 1

#define	SOAP_BEGIN_RECV 2

#define	SOAP_IN_ENVELOPE 3

#define	SOAP_IN_HEADER 4

#define	SOAP_END_HEADER 5

#define	SOAP_NO_BODY 6

#define	SOAP_IN_BODY 7

#define	SOAP_END_BODY 8

#define	SOAP_END_ENVELOPE 9

#define	SOAP_SEC_BEGIN 1

#define	SOAP_SEC_SIGN 2

#define	SOAP_SEC_DECRYPT 3

#define	SOAP_MALLOC(soap, size) malloc((size))

#define	SOAP_FREE(soap, ptr) free((void*)(ptr))

#define	SOAP_MALLOC_UNMANAGED(size) malloc((size))

#define	SOAP_FREE_UNMANAGED(ptr) free((void*)(ptr))

#define	SOAP_NOTHROW (std::nothrow)

#define	SOAP_NEW(soap, type) new SOAP_NOTHROW (type)

#define	SOAP_NEW_ARRAY(soap, type, n) new SOAP_NOTHROW type[n]

#define	SOAP_PLACEMENT_NEW(soap, buf, type) new (buf) (type)

#define	SOAP_DELETE(soap, obj, type) delete obj

#define	SOAP_DELETE_ARRAY(soap, obj, type) delete[] obj

#define	SOAP_NEW_UNMANAGED(soap) new SOAP_NOTHROW soap

#define	SOAP_DELETE_UNMANAGED(soap) delete soap

#define	DBGLOG(DBGFILE, CMD)

#define	DBGMSG(DBGFILE, MSG, LEN)

#define	DBGFUN(FNAME)

#define	DBGFUN1(FNAME, FMT, ARG)

#define	DBGFUN2(FNAME, FMT1, ARG1, FMT2, ARG2)

#define	DBGFUN3(FNAME, FMT1, ARG1, FMT2, ARG2, FMT3, ARG3)

#define	DBGFUN4(FNAME, FMT1, ARG1, FMT2, ARG2, FMT3, ARG3, FMT4, ARG4)

#define	DBGHEX(DBGFILE, MSG, LEN)

#define	soap_get0(soap) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx])

#define	soap_get1(soap) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx++])

#define	soap_versioning_paste(name, ext) name##_REQUIRE_lib_v##ext

#define	soap_versioning_ext(name, ext) soap_versioning_paste(name, ext)

#define	soap_versioning(name) soap_versioning_ext(name, GSOAP_VERSION)

#define	soap_init(soap) soap_init1(soap, SOAP_IO_DEFAULT)

#define	soap_init1(soap, mode) soap_init2(soap, mode, mode)

#define	soap_init2(soap, imode, omode) soap_versioning(soap_init)(soap, imode, omode)

#define	soap_new() soap_new1(SOAP_IO_DEFAULT)

#define	soap_new1(mode) soap_new2(mode, mode)

#define	soap_new2(imode, omode) soap_versioning(soap_new)(imode, omode)

#define	soap_revget1(soap) ((soap)->bufidx--)

#define	soap_unget(soap, c) ((soap)->ahead = c)

#define	soap_peek(soap) ((soap)->ahead = soap_get(soap))

#define	soap_register_plugin(soap, plugin) soap_register_plugin_arg(soap, plugin, NULL)

#define	soap_mode(soap, n) ((soap)->mode = (soap)->imode = (soap)->omode = (n))

#define	soap_imode(soap, n) ((soap)->imode = (n))

#define	soap_omode(soap, n) ((soap)->omode = (n))

#define	soap_set_imode(soap, n) ((soap)->imode \|= (n))

#define	soap_clr_imode(soap, n) ((soap)->imode &= ~(n))

#define	soap_set_omode(soap, n) ((soap)->omode \|= (n))

#define	soap_clr_omode(soap, n) ((soap)->omode &= ~(n))

#define	soap_set_mode(soap, n) ((soap)->mode \|= (n), (soap)->imode \|= (n), (soap)->omode \|= (n))

#define	soap_clr_mode(soap, n) ((soap)->mode &= ~(n), (soap)->imode &= ~(n), (soap)->omode &= ~(n))

#define	soap_destroy(soap) soap_delete((soap), NULL)

#define	SOAP_NO_LINK_TO_DELETE (-2) /* pass to soap_link() as size n: do not manage, smart pointers are self-managing */

#define	soap_strrchr(s, t) strrchr(s, t)

#define	soap_strtol(s, t, b) strtol(s, t, b)

#define	soap_strtoul(s, t, b) strtoul(s, t, b)

#define	soap_strtoll strtoll

#define	soap_strtoull strtoull

#define	soap_random rand()

Typedefs
typedef soap_int32	soap_status

typedef int	soap_http_command

typedef soap_int32	soap_mode

typedef unsigned short	soap_ssl_flags

typedef soap_int32	soap_wchar

typedef void	soap_walker(struct soap , void , int, const char , const char )

Enumerations
enum	soap_mime_encoding { SOAP_MIME_NONE , SOAP_MIME_7BIT , SOAP_MIME_8BIT , SOAP_MIME_BINARY , SOAP_MIME_QUOTED_PRINTABLE , SOAP_MIME_BASE64 , SOAP_MIME_IETF_TOKEN , SOAP_MIME_X_TOKEN }

Functions
SOAP_FMAC1 void SOAP_FMAC2	soap_strcat (char buf, size_t len, const char src)

SOAP_FMAC1 int SOAP_FMAC2	soap_strncat (char buf, size_t len, const char src, size_t num)

SOAP_FMAC1 struct soap_multipart *SOAP_FMAC2	soap_next_multipart (struct soap_multipart *)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_new (struct soap soap, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_new_w (struct soap soap, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_set (struct soap_dom_element elt, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_set_w (struct soap_dom_element elt, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att (struct soap_dom_element elt, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_w (struct soap_dom_element elt, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt (struct soap_dom_element elt, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_w (struct soap_dom_element elt, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_nth_elt (struct soap_dom_element elt, const char ns, const char *tag, size_t n)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_nth_elt_w (struct soap_dom_element elt, const char ns, const wchar_t *tag, size_t n)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_nth (struct soap_dom_element *elt, size_t n)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_add_att (struct soap_dom_element elt, const struct soap_dom_attribute node)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_add_elt (struct soap_dom_element elt, const struct soap_dom_element node)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_add_atts (struct soap_dom_element elt, const struct soap_dom_attribute atts)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_add_elts (struct soap_dom_element elt, const struct soap_dom_element elts)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_bool (struct soap_dom_element *elt, LONG64 b)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_int (struct soap_dom_element *elt, LONG64 n)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_double (struct soap_dom_element *elt, double x)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_text (struct soap_dom_element elt, const char text)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_text_w (struct soap_dom_element elt, const wchar_t text)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_node (struct soap_dom_element elt, const void node, int type)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_copy (struct soap_dom_element elt, const struct soap_dom_element node)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_match (const struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_match_w (const struct soap_dom_element elt, const char ns, const wchar_t *patt)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_elt_get_ns (const struct soap_dom_element *elt)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_elt_get_tag (const struct soap_dom_element *elt)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_is_true (const struct soap_dom_element *elt)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_is_false (const struct soap_dom_element *elt)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_get_int (const struct soap_dom_element *elt)

SOAP_FMAC1 long SOAP_FMAC2	soap_elt_get_long (const struct soap_dom_element *elt)

SOAP_FMAC1 LONG64 SOAP_FMAC2	soap_elt_get_LONG64 (const struct soap_dom_element *elt)

SOAP_FMAC1 double SOAP_FMAC2	soap_elt_get_double (const struct soap_dom_element *elt)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_elt_get_text (const struct soap_dom_element *elt)

SOAP_FMAC1 const void *SOAP_FMAC2	soap_elt_get_node (const struct soap_dom_element *elt, int type)

SOAP_FMAC1 int SOAP_FMAC2	soap_elt_get_type (const struct soap_dom_element elt, const void *node)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_parent (const struct soap_dom_element *elt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_depth (const struct soap_dom_element *elt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_index (const struct soap_dom_element *elt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_len (const struct soap_dom_element *elt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_nth (const struct soap_dom_element *elt)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_new (struct soap soap, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_new_w (struct soap soap, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_set (struct soap_dom_attribute att, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_set_w (struct soap_dom_attribute att, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_add (struct soap_dom_attribute att, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_add_w (struct soap_dom_attribute att, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_bool (struct soap_dom_attribute *att, LONG64 b)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_int (struct soap_dom_attribute *att, LONG64 n)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_double (struct soap_dom_attribute *att, double x)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_text (struct soap_dom_attribute att, const char text)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_text_w (struct soap_dom_attribute att, const wchar_t text)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_copy (struct soap_dom_attribute att, const struct soap_dom_attribute node)

SOAP_FMAC1 int SOAP_FMAC2	soap_att_match (const struct soap_dom_attribute att, const char ns, const char *patt)

SOAP_FMAC1 int SOAP_FMAC2	soap_att_match_w (const struct soap_dom_attribute att, const char ns, const wchar_t *patt)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_att_get_ns (const struct soap_dom_attribute *att)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_att_get_tag (const struct soap_dom_attribute *att)

SOAP_FMAC1 int SOAP_FMAC2	soap_att_is_true (const struct soap_dom_attribute *att)

SOAP_FMAC1 int SOAP_FMAC2	soap_att_is_false (const struct soap_dom_attribute *att)

SOAP_FMAC1 int SOAP_FMAC2	soap_att_get_int (const struct soap_dom_attribute *att)

SOAP_FMAC1 long SOAP_FMAC2	soap_att_get_long (const struct soap_dom_attribute *att)

SOAP_FMAC1 LONG64 SOAP_FMAC2	soap_att_get_LONG64 (const struct soap_dom_attribute *att)

SOAP_FMAC1 double SOAP_FMAC2	soap_att_get_double (const struct soap_dom_attribute *att)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_att_get_text (const struct soap_dom_attribute *att)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_first (struct soap_dom_element *elt)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_next (const struct soap_dom_attribute *att)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_first (struct soap_dom_element *elt)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_next (const struct soap_dom_element *elt)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_get (const struct soap_dom_element elt, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_get_w (const struct soap_dom_element elt, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_get (const struct soap_dom_element elt, const char ns, const char *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_get_w (const struct soap_dom_element elt, const char ns, const wchar_t *tag)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_get_next (const struct soap_dom_element *elt)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_get_nth (struct soap_dom_element *elt, size_t n)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_find (struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_att_find_next (const struct soap_dom_attribute att, const char ns, const char *patt)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_find (struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_find_next (const struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_find_type (struct soap_dom_element elt, const char ns, const char *patt, int type)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_elt_find_next_type (const struct soap_dom_element elt, const char ns, const char *patt, int type)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_att_size (struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_size (struct soap_dom_element elt, const char ns, const char *patt)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_elt_size_type (struct soap_dom_element elt, const char ns, const char *patt, int type)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_dom_next_attribute (const struct soap_dom_attribute *att)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_dom_next_element (const struct soap_dom_element elt, const struct soap_dom_element end)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_dom_find (struct soap_dom_element begin, const struct soap_dom_element end, const char ns, const char patt, int type)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_dom_find_next (const struct soap_dom_element elt, const struct soap_dom_element end, const char ns, const char patt, int type)

SOAP_FMAC1 struct soap_dom_element *SOAP_FMAC2	soap_dup_xsd__anyType (struct soap soap, struct soap_dom_element d, const struct soap_dom_element *a)

SOAP_FMAC1 void SOAP_FMAC2	soap_del_xsd__anyType (const struct soap_dom_element *a)

SOAP_FMAC1 struct soap_dom_attribute *SOAP_FMAC2	soap_dup_xsd__anyAttribute (struct soap soap, struct soap_dom_attribute d, const struct soap_dom_attribute *a)

SOAP_FMAC1 void SOAP_FMAC2	soap_del_xsd__anyAttribute (const struct soap_dom_attribute *a)

SOAP_FMAC1 int SOAP_FMAC2	soap_dom_call (struct soap soap, const char endpoint, const char action, const struct soap_dom_element in, struct soap_dom_element *out)

SOAP_FMAC5 int SOAP_FMAC6	soap_serve (struct soap *soap)

SOAP_FMAC5 int SOAP_FMAC6	soap_serve_request (struct soap *soap)

SOAP_FMAC1 void SOAP_FMAC2	soap_ssl_init (void)

SOAP_FMAC1 void SOAP_FMAC2	soap_ssl_noinit (void)

SOAP_FMAC1 int SOAP_FMAC2	soap_GET (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_PUT (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_PATCH (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_POST (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_DELETE (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_connect_command (struct soap , int, const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_connect (struct soap , const char , const char *)

SOAP_FMAC1 SOAP_SOCKET SOAP_FMAC2	soap_bind (struct soap , const char , int, int)

SOAP_FMAC1 SOAP_SOCKET SOAP_FMAC2	soap_accept (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_ssl_accept (struct soap *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_ssl_error (struct soap *, int ret, int err)

SOAP_FMAC1 int SOAP_FMAC2	soap_ssl_crl (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_poll (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_ready (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_ssl_server_context (struct soap soap, unsigned short flags, const char keyfile, const char password, const char cafile, const char capath, const char dhfile, const char randfile, const char sid)

SOAP_FMAC1 int SOAP_FMAC2	soap_ssl_client_context (struct soap soap, unsigned short flags, const char keyfile, const char password, const char cafile, const char capath, const char randfile)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_http_content_type (struct soap *soap, int status)

SOAP_FMAC1 int SOAP_FMAC2	soap_puthttphdr (struct soap *, int status, ULONG64 count)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_http_header_attribute (struct soap , const char , const char *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_decode_key (char , size_t, const char )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_decode_val (char , size_t, const char )

SOAP_FMAC1 size_t SOAP_FMAC2	soap_hash (const char *)

SOAP_FMAC1 void SOAP_FMAC2	soap_set_endpoint (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_flush_raw (struct soap , const char , size_t)

SOAP_FMAC1 int SOAP_FMAC2	soap_flush (struct soap *)

SOAP_FMAC1 soap_wchar SOAP_FMAC2	soap_get (struct soap *)

SOAP_FMAC1 soap_wchar SOAP_FMAC2	soap_getchar (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_tag_cmp (const char , const char )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_fault (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_sender_fault (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_sender_fault_subcode (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_receiver_fault (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_receiver_fault_subcode (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_set_sender_error (struct soap , const char , const char *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_set_receiver_error (struct soap , const char , const char *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_send_raw (struct soap , const char , size_t)

SOAP_FMAC1 int SOAP_FMAC2	soap_recv_raw (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_recv (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_send (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_send2 (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_send3 (struct soap , const char , const char , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_query_send_key (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_query_send_val (struct soap , const char )

SOAP_FMAC1 char *SOAP_FMAC2	soap_query (struct soap *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_query_key (struct soap , char *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_query_val (struct soap , char *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_query_decode (char , size_t, const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_pututf8 (struct soap *, unsigned long)

SOAP_FMAC1 soap_wchar SOAP_FMAC2	soap_getutf8 (struct soap *)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_utf8len (const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_putbase64 (struct soap , const unsigned char , int)

SOAP_FMAC1 unsigned char *SOAP_FMAC2	soap_getbase64 (struct soap , int , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_puthex (struct soap , const unsigned char , int)

SOAP_FMAC1 unsigned char *SOAP_FMAC2	soap_gethex (struct soap , int )

SOAP_FMAC1 int SOAP_FMAC2	soap_xop_forward (struct soap , unsigned char , int , char , char , char **)

SOAP_FMAC1 int SOAP_FMAC2	soap_attachment_forward (struct soap , unsigned char , int , char , char , char **)

SOAP_FMAC1 int SOAP_FMAC2	soap_pointer_lookup (struct soap , const void p, int t, struct soap_plist **)

SOAP_FMAC1 int SOAP_FMAC2	soap_pointer_enter (struct soap , const void p, const void a, int n, int t, struct soap_plist *)

SOAP_FMAC1 int SOAP_FMAC2	soap_array_pointer_lookup (struct soap , const void p, const void a, int n, int t, struct soap_plist *)

SOAP_FMAC1 int SOAP_FMAC2	soap_pointer_lookup_id (struct soap , void p, int t, struct soap_plist **)

SOAP_FMAC1 int SOAP_FMAC2	soap_embed (struct soap soap, const void p, const void *a, int n, int t)

SOAP_FMAC1 struct soap_ilist *SOAP_FMAC2	soap_lookup (struct soap , const char )

SOAP_FMAC1 struct soap_ilist *SOAP_FMAC2	soap_enter (struct soap , const char , int t, size_t n)

SOAP_FMAC1 int SOAP_FMAC2	soap_resolve (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_embedded (struct soap , const void p, int t)

SOAP_FMAC1 int SOAP_FMAC2	soap_reference (struct soap , const void p, int t)

SOAP_FMAC1 int SOAP_FMAC2	soap_array_reference (struct soap , const void p, const void *a, int n, int t)

SOAP_FMAC1 int SOAP_FMAC2	soap_attachment_reference (struct soap soap, const void p, const void a, int n, int t, const char id, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_embedded_id (struct soap , int id, const void p, int t)

SOAP_FMAC1 int SOAP_FMAC2	soap_is_embedded (struct soap , struct soap_plist )

SOAP_FMAC1 int SOAP_FMAC2	soap_is_single (struct soap , struct soap_plist )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_embedded (struct soap , struct soap_plist )

SOAP_FMAC1 int SOAP_FMAC2	soap_check_and_mark (struct soap soap, const void p, int t, char **mark)

SOAP_FMAC1 void *SOAP_FMAC2	soap_mark_lookup (struct soap soap, const void p, int t, struct soap_plist pp, char mark)

SOAP_FMAC1 int SOAP_FMAC2	soap_mark_cycle (struct soap soap, struct soap_plist pp)

SOAP_FMAC1 void SOAP_FMAC2	soap_mark_dup (struct soap soap, void a, struct soap_plist *pp)

SOAP_FMAC1 void SOAP_FMAC2	soap_unmark (struct soap soap, char mark)

SOAP_FMAC1 int SOAP_FMAC2	soap_begin_count (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_end_count (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_begin_send (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_end_send (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_end_send_flush (struct soap *)

SOAP_FMAC1 const struct soap_code_map *SOAP_FMAC2	soap_code (const struct soap_code_map , const char )

SOAP_FMAC1 LONG64 SOAP_FMAC2	soap_code_int (const struct soap_code_map , const char , LONG64)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_code_str (const struct soap_code_map *, long)

SOAP_FMAC1 LONG64 SOAP_FMAC2	soap_code_bits (const struct soap_code_map , const char )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_code_list (struct soap , const struct soap_code_map , long)

SOAP_FMAC1 int SOAP_FMAC2	soap_binary_search_string (const char *, int, const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_getline (struct soap , char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_begin_serve (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_begin_recv (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_end_recv (struct soap *)

SOAP_FMAC1 void *SOAP_FMAC2	soap_malloc (struct soap *, size_t)

SOAP_FMAC1 void SOAP_FMAC2	soap_dealloc (struct soap , void )

SOAP_FMAC1 struct soap_clist *SOAP_FMAC2	soap_link (struct soap , int, int, int(fdelete)(struct soap , struct soap_clist ))

SOAP_FMAC1 int SOAP_FMAC2	soap_unlink (struct soap , const void )

SOAP_FMAC1 void SOAP_FMAC2	soap_free_temp (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_del (struct soap *)

SOAP_FMAC1 void *SOAP_FMAC2	soap_track_malloc (struct soap , const char , int, size_t)

SOAP_FMAC1 void SOAP_FMAC2	soap_track_free (struct soap , const char , int, void *)

SOAP_FMAC1 int SOAP_FMAC2	soap_lookup_type (struct soap , const char id)

SOAP_FMAC1 short SOAP_FMAC2	soap_begin_shaky (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_end_shaky (struct soap *, short)

SOAP_FMAC1 void *SOAP_FMAC2	soap_id_lookup (struct soap , const char id, void *p, int t, size_t n, unsigned int k, int(fbase)(int, int))

SOAP_FMAC1 void *SOAP_FMAC2	soap_id_forward (struct soap , const char id, void p, size_t i, int t, int tt, size_t n, unsigned int k, void(finsert)(struct soap , int, int, void , size_t, const void , void ), int(fbase)(int, int))

SOAP_FMAC1 int SOAP_FMAC2	soap_id_nullify (struct soap , const char )

SOAP_FMAC1 void *SOAP_FMAC2	soap_id_enter (struct soap , const char id, void p, int t, size_t n, const char type, const char arrayType, void (finstantiate)(struct soap , int, const char , const char , size_t ), int(fbase)(int, int))

SOAP_FMAC1 void **SOAP_FMAC2	soap_id_smart (struct soap soap, const char , int t, size_t n)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_size (const int *, int)

SOAP_FMAC1 size_t SOAP_FMAC2	soap_getsizes (const char , int , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_getoffsets (const char , const int , int *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_getposition (const char , int )

SOAP_FMAC1 char *SOAP_FMAC2	soap_putsizesoffsets (struct soap , const char , const int , const int , int)

SOAP_FMAC1 char *SOAP_FMAC2	soap_putoffsets (struct soap , const int , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_closesock (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_force_closesock (struct soap *)

SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_versioning()	soap_new (soap_mode, soap_mode)

SOAP_FMAC1 void SOAP_FMAC2	soap_free (struct soap *)

SOAP_FMAC1 struct soap *SOAP_FMAC2	soap_copy (const struct soap *)

SOAP_FMAC1 struct soap *SOAP_FMAC2	soap_copy_context (struct soap , const struct soap )

SOAP_FMAC1 void SOAP_FMAC2	soap_copy_stream (struct soap , struct soap )

SOAP_FMAC1 void SOAP_FMAC2	soap_free_stream (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2 soap_versioning()	soap_init (struct soap *, soap_mode, soap_mode)

SOAP_FMAC1 void SOAP_FMAC2	soap_initialize (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_done (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_cleanup (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_begin (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_end (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_delete (struct soap , void )

SOAP_FMAC1 void SOAP_FMAC2	soap_delegate_deletion (struct soap , struct soap )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_recv_logfile (struct soap , const char )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_sent_logfile (struct soap , const char )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_test_logfile (struct soap , const char )

SOAP_FMAC1 void SOAP_FMAC2	soap_close_logfiles (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_open_logfile (struct soap *, int)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_value (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_match_tag (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_match_att (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_match_array (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_element (struct soap , const char , int, const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_start_end_out (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_begin_out (struct soap , const char tag, int id, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_array_begin_out (struct soap , const char tag, int id, const char type, const char offset)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_ref (struct soap , const char tag, int id, int href)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_href (struct soap , const char tag, int id, const char ref, const char val)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_null (struct soap , const char tag, int id, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_empty (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_nil (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_id (struct soap , const char tag, int id, const void p, const void a, int n, const char type, int t, char *mark)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_result (struct soap , const char tag)

SOAP_FMAC1 void SOAP_FMAC2	soap_check_result (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_end_out (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_end (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_attribute (struct soap , const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_begin_in (struct soap , const char tag, int nillable, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_element_end_in (struct soap , const char tag)

SOAP_FMAC1 int SOAP_FMAC2	soap_peek_element (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_retry (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_revert (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_ignore (struct soap *)

SOAP_FMAC1 void *SOAP_FMAC2	soap_memdup (struct soap , const void , size_t)

SOAP_FMAC1 char *SOAP_FMAC2	soap_strdup (struct soap , const char )

SOAP_FMAC1 wchar_t *SOAP_FMAC2	soap_wstrdup (struct soap , const wchar_t )

SOAP_FMAC1 char *SOAP_FMAC2	soap_strtrim (struct soap , char )

SOAP_FMAC1 wchar_t *SOAP_FMAC2	soap_wstrtrim (struct soap , wchar_t )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_tagsearch (const char big, const char little)

SOAP_FMAC1 int SOAP_FMAC2	soap_string_out (struct soap , const char s, int flag)

SOAP_FMAC1 char *SOAP_FMAC2	soap_string_in (struct soap , int, long, long, const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_wstring_out (struct soap , const wchar_t s, int flag)

SOAP_FMAC1 wchar_t *SOAP_FMAC2	soap_wstring_in (struct soap , int, long, long, const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_match_namespace (struct soap , const char , const char *, size_t n1, size_t n2)

SOAP_FMAC1 void SOAP_FMAC2	soap_set_version (struct soap *, short)

SOAP_FMAC1 int SOAP_FMAC2	soap_set_namespaces (struct soap , const struct Namespace )

SOAP_FMAC1 void SOAP_FMAC2	soap_set_local_namespaces (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_pop_namespace (struct soap *)

SOAP_FMAC1 struct soap_nlist *SOAP_FMAC2	soap_push_namespace (struct soap , const char , const char *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_current_namespace_tag (struct soap soap, const char tag)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_current_namespace_att (struct soap soap, const char tag)

SOAP_FMAC1 struct soap_nlist *SOAP_FMAC2	soap_lookup_ns (struct soap soap, const char tag, size_t n)

SOAP_FMAC1 int SOAP_FMAC2	soap_store_lab (struct soap , const char , size_t)

SOAP_FMAC1 int SOAP_FMAC2	soap_append_lab (struct soap , const char , size_t)

SOAP_FMAC1 struct soap_blist *SOAP_FMAC2	soap_alloc_block (struct soap *)

SOAP_FMAC1 void *SOAP_FMAC2	soap_push_block (struct soap , struct soap_blist , size_t)

SOAP_FMAC1 void *SOAP_FMAC2	soap_push_block_max (struct soap , struct soap_blist , size_t)

SOAP_FMAC1 void SOAP_FMAC2	soap_pop_block (struct soap , struct soap_blist )

SOAP_FMAC1 size_t SOAP_FMAC2	soap_size_block (struct soap , struct soap_blist , size_t)

SOAP_FMAC1 char *SOAP_FMAC2	soap_first_block (struct soap , struct soap_blist )

SOAP_FMAC1 char *SOAP_FMAC2	soap_next_block (struct soap , struct soap_blist )

SOAP_FMAC1 size_t SOAP_FMAC2	soap_block_size (struct soap , struct soap_blist )

SOAP_FMAC1 char *SOAP_FMAC2	soap_save_block (struct soap , struct soap_blist , char *, int)

SOAP_FMAC1 void SOAP_FMAC2	soap_end_block (struct soap , struct soap_blist )

SOAP_FMAC1 void SOAP_FMAC2	soap_update_pointers (struct soap soap, const char dst, const char *src, size_t len)

SOAP_FMAC1 int SOAP_FMAC2	soap_envelope_begin_out (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_envelope_end_out (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_http_has_body (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_http_skip_body (struct soap *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_http_get_body (struct soap , size_t len)

SOAP_FMAC1 char *SOAP_FMAC2	soap_http_get_form (struct soap *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_http_get_body_prefix (struct soap , size_t len, const char *prefix)

SOAP_FMAC1 int SOAP_FMAC2	soap_envelope_begin_in (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_envelope_end_in (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_body_begin_out (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_body_end_out (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_body_begin_in (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_body_end_in (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_recv_header (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_response (struct soap *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_send_empty_response (struct soap *, int status)

SOAP_FMAC1 int SOAP_FMAC2	soap_recv_empty_response (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_send_fault (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_recv_fault (struct soap *, int check)

SOAP_FMAC1 void SOAP_FMAC2	soap_print_fault (struct soap , FILE )

SOAP_FMAC1 void SOAP_FMAC2	soap_print_fault_location (struct soap , FILE )

SOAP_FMAC1 char *SOAP_FMAC2	soap_sprint_fault (struct soap , char , size_t)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2byte (struct soap , const char , char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2short (struct soap , const char , short *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2int (struct soap , const char , int *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2long (struct soap , const char , long *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2LONG64 (struct soap , const char , LONG64 *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2float (struct soap , const char , float *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2double (struct soap , const char , double *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2unsignedByte (struct soap , const char , unsigned char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2unsignedShort (struct soap , const char , unsigned short *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2unsignedInt (struct soap , const char , unsigned int *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2unsignedLong (struct soap , const char , unsigned long *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2ULONG64 (struct soap , const char , ULONG64 *)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2char (struct soap , const char , char *, int, long minlen, long maxlen, const char pattern)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2QName (struct soap , const char , char *, long minlen, long maxlen, const char pattern)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2wchar (struct soap , const char , wchar_t *, int, long minlen, long maxlen, const char pattern)

SOAP_FMAC1 int SOAP_FMAC2	soap_s2dateTime (struct soap , const char , time_t *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_s2base64 (struct soap , const unsigned char , char *, int)

SOAP_FMAC1 char *SOAP_FMAC2	soap_s2hex (struct soap , const unsigned char , char *, int)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_byte2s (struct soap *, char)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_short2s (struct soap *, short)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_int2s (struct soap *, int)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_long2s (struct soap *, long)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_LONG642s (struct soap *, LONG64)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_float2s (struct soap *, float)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_double2s (struct soap *, double)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_unsignedByte2s (struct soap *, unsigned char)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_unsignedShort2s (struct soap *, unsigned short)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_unsignedInt2s (struct soap *, unsigned int)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_unsignedLong2s (struct soap *, unsigned long)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_ULONG642s (struct soap *, ULONG64)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_QName2s (struct soap , const char )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_wchar2s (struct soap , const wchar_t )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_dateTime2s (struct soap *, time_t)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_base642s (struct soap , const char , char , size_t, int )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_hex2s (struct soap , const char , char , size_t, int )

SOAP_FMAC1 int *SOAP_FMAC2	soap_inint (struct soap , const char tag, int p, const char , int)

SOAP_FMAC1 char *SOAP_FMAC2	soap_inbyte (struct soap , const char tag, char p, const char , int)

SOAP_FMAC1 long *SOAP_FMAC2	soap_inlong (struct soap , const char tag, long p, const char , int)

SOAP_FMAC1 LONG64 *SOAP_FMAC2	soap_inLONG64 (struct soap , const char tag, LONG64 p, const char , int)

SOAP_FMAC1 short *SOAP_FMAC2	soap_inshort (struct soap , const char tag, short p, const char , int)

SOAP_FMAC1 float *SOAP_FMAC2	soap_infloat (struct soap , const char tag, float p, const char , int)

SOAP_FMAC1 double *SOAP_FMAC2	soap_indouble (struct soap , const char tag, double p, const char , int)

SOAP_FMAC1 unsigned char *SOAP_FMAC2	soap_inunsignedByte (struct soap , const char tag, unsigned char p, const char , int)

SOAP_FMAC1 unsigned short *SOAP_FMAC2	soap_inunsignedShort (struct soap , const char tag, unsigned short p, const char , int)

SOAP_FMAC1 unsigned int *SOAP_FMAC2	soap_inunsignedInt (struct soap , const char tag, unsigned int p, const char , int)

SOAP_FMAC1 unsigned long *SOAP_FMAC2	soap_inunsignedLong (struct soap , const char tag, unsigned long p, const char , int)

SOAP_FMAC1 ULONG64 *SOAP_FMAC2	soap_inULONG64 (struct soap , const char tag, ULONG64 p, const char , int)

SOAP_FMAC1 char **SOAP_FMAC2	soap_instring (struct soap , const char tag, char *p, const char , int, int, long, long, const char *)

SOAP_FMAC1 char **SOAP_FMAC2	soap_inliteral (struct soap , const char tag, char **p)

SOAP_FMAC1 time_t *SOAP_FMAC2	soap_indateTime (struct soap , const char tag, time_t p, const char , int)

SOAP_FMAC1 time_t SOAP_FMAC2	soap_timegm (struct tm *)

SOAP_FMAC1 wchar_t **SOAP_FMAC2	soap_inwstring (struct soap , const char tag, wchar_t *p, const char , int, int, long, long, const char *)

SOAP_FMAC1 wchar_t **SOAP_FMAC2	soap_inwliteral (struct soap , const char tag, wchar_t **p)

SOAP_FMAC1 int SOAP_FMAC2	soap_outbyte (struct soap , const char tag, int id, const char p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outshort (struct soap , const char tag, int id, const short p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outint (struct soap , const char tag, int id, const int p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outlong (struct soap , const char tag, int id, const long p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outLONG64 (struct soap , const char tag, int id, const LONG64 p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outfloat (struct soap , const char tag, int id, const float p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outdouble (struct soap , const char tag, int id, const double p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outunsignedByte (struct soap , const char tag, int id, const unsigned char p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outunsignedShort (struct soap , const char tag, int id, const unsigned short p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outunsignedInt (struct soap , const char tag, int id, const unsigned int p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outunsignedLong (struct soap , const char tag, int id, const unsigned long p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outULONG64 (struct soap , const char tag, int id, const ULONG64 p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outstring (struct soap , const char tag, int id, char const p, const char *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outliteral (struct soap , const char tag, char const p, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_outdateTime (struct soap , const char tag, int id, const time_t p, const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outwstring (struct soap , const char tag, int id, wchar_t const p, const char *, int)

SOAP_FMAC1 int SOAP_FMAC2	soap_outwliteral (struct soap , const char tag, wchar_t const p, const char *type)

SOAP_FMAC1 int SOAP_FMAC2	soap_attachment (struct soap , const char , int, const void , const void , int, const char , const char , const char , const char , int)

SOAP_FMAC1 int SOAP_FMAC2	soap_move (struct soap *, ULONG64)

SOAP_FMAC1 ULONG64 SOAP_FMAC2	soap_tell (struct soap *)

SOAP_FMAC1 char *SOAP_FMAC2	soap_dime_option (struct soap , unsigned short, const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_getdimehdr (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_getdime (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_putdimehdr (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_putdime (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_getmimehdr (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_getmime (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_putmimehdr (struct soap , struct soap_multipart )

SOAP_FMAC1 int SOAP_FMAC2	soap_putmime (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_set_dime (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_set_mime (struct soap , const char boundary, const char *start)

SOAP_FMAC1 void SOAP_FMAC2	soap_clr_dime (struct soap *)

SOAP_FMAC1 void SOAP_FMAC2	soap_clr_mime (struct soap *)

SOAP_FMAC1 int SOAP_FMAC2	soap_set_dime_attachment (struct soap , const char ptr, size_t size, const char type, const char id, unsigned short optype, const char *option)

SOAP_FMAC1 int SOAP_FMAC2	soap_set_mime_attachment (struct soap , const char ptr, size_t size, enum soap_mime_encoding encoding, const char type, const char id, const char location, const char description)

SOAP_FMAC1 void SOAP_FMAC2	soap_post_check_mime_attachments (struct soap *soap)

SOAP_FMAC1 int SOAP_FMAC2	soap_check_mime_attachments (struct soap *soap)

SOAP_FMAC1 struct soap_multipart *SOAP_FMAC2	soap_recv_mime_attachment (struct soap soap, void handle)

SOAP_FMAC1 int SOAP_FMAC2	soap_match_cid (struct soap , const char , const char *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_rand_uuid (struct soap , const char )

SOAP_FMAC1 int SOAP_FMAC2	soap_register_plugin_arg (struct soap , int(fcreate)(struct soap , struct soap_plugin , void ), void )

SOAP_FMAC1 void *SOAP_FMAC2	soap_lookup_plugin (struct soap , const char )

SOAP_FMAC1 const char *SOAP_FMAC2	soap_attr_value (struct soap soap, const char name, int flag, int occurs)

SOAP_FMAC1 int SOAP_FMAC2	soap_set_attr (struct soap soap, const char name, const char *value, int flag)

SOAP_FMAC1 void SOAP_FMAC2	soap_clr_attr (struct soap *soap)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_extend_url (struct soap soap, const char , const char *)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_extend_url_query (struct soap soap, const char , const char *)

SOAP_FMAC1 void SOAP_FMAC2	soap_url_query (struct soap soap, const char , const char *)

SOAP_FMAC1 int SOAP_FMAC2	soap_encode_url (const char , char , int)

SOAP_FMAC1 const char *SOAP_FMAC2	soap_encode_url_string (struct soap , const char )

SOAP_FMAC3 void SOAP_FMAC4	soap_header (struct soap *)

SOAP_FMAC3 void SOAP_FMAC4	soap_fault (struct soap *)

SOAP_FMAC3 const char **SOAP_FMAC4	soap_faultcode (struct soap *)

SOAP_FMAC3 const char **SOAP_FMAC4	soap_faultsubcode (struct soap *)

SOAP_FMAC3 const char **SOAP_FMAC4	soap_faultstring (struct soap *)

SOAP_FMAC3 const char **SOAP_FMAC4	soap_faultdetail (struct soap *)

SOAP_FMAC3 const char *SOAP_FMAC4	soap_fault_subcode (struct soap *)

SOAP_FMAC3 const char *SOAP_FMAC4	soap_fault_string (struct soap *)

SOAP_FMAC3 const char *SOAP_FMAC4	soap_fault_detail (struct soap *)

SOAP_FMAC3 void SOAP_FMAC4	soap_serializefault (struct soap *)

SOAP_FMAC3 void SOAP_FMAC4	soap_serializeheader (struct soap *)

SOAP_FMAC3 int SOAP_FMAC4	soap_getheader (struct soap *)

SOAP_FMAC3 int SOAP_FMAC4	soap_putheader (struct soap *)

SOAP_FMAC3 int SOAP_FMAC4	soap_getfault (struct soap *)

SOAP_FMAC3 int SOAP_FMAC4	soap_putfault (struct soap *)

Variables
const union soap_double_nan	soap_double_nan

const char	soap_base64o []

const char	soap_base64i []

struct SOAP_CMAC	soap

struct SOAP_CMAC	soap_dom_element

struct SOAP_CMAC	soap_dom_attribute

SOAP_NMAC struct Namespace	namespaces []

Macro Definition Documentation

◆ _REENTRANT

#define _REENTRANT

Definition at line 67 of file stdsoap2.h.

◆ _THREAD_SAFE

#define _THREAD_SAFE

Definition at line 62 of file stdsoap2.h.

◆ DBGFUN

#define DBGFUN ( FNAME )

Definition at line 1985 of file stdsoap2.h.

◆ DBGFUN1

#define DBGFUN1	(	FNAME,
		FMT,
		ARG
	)

Definition at line 1986 of file stdsoap2.h.

◆ DBGFUN2

#define DBGFUN2	(	FNAME,
		FMT1,
		ARG1,
		FMT2,
		ARG2
	)

Definition at line 1987 of file stdsoap2.h.

◆ DBGFUN3

#define DBGFUN3	(	FNAME,
		FMT1,
		ARG1,
		FMT2,
		ARG2,
		FMT3,
		ARG3
	)

Definition at line 1988 of file stdsoap2.h.

◆ DBGFUN4

#define DBGFUN4	(	FNAME,
		FMT1,
		ARG1,
		FMT2,
		ARG2,
		FMT3,
		ARG3,
		FMT4,
		ARG4
	)

Definition at line 1989 of file stdsoap2.h.

◆ DBGHEX

#define DBGHEX	(	DBGFILE,
		MSG,
		LEN
	)

Definition at line 1990 of file stdsoap2.h.

◆ DBGLOG

#define DBGLOG	(	DBGFILE,
		CMD
	)

Definition at line 1983 of file stdsoap2.h.

◆ DBGMSG

#define DBGMSG	(	DBGFILE,
		MSG,
		LEN
	)

Definition at line 1984 of file stdsoap2.h.

◆ DBL_NAN

#define DBL_NAN (soap_double_nan.dv)

Definition at line 1412 of file stdsoap2.h.

◆ DBL_NINFTY

#define DBL_NINFTY (-DBL_PINFTY)

Definition at line 1432 of file stdsoap2.h.

◆ DBL_PINFTY

#define DBL_PINFTY (1.7976931348623157e+308)

Definition at line 1427 of file stdsoap2.h.

◆ FD_SETSIZE

#define FD_SETSIZE (1024)

Definition at line 1006 of file stdsoap2.h.

◆ FLT_NAN

#define FLT_NAN (soap_double_nan.fv)

Definition at line 1388 of file stdsoap2.h.

◆ FLT_NINFTY

#define FLT_NINFTY (-FLT_PINFTY)

Definition at line 1408 of file stdsoap2.h.

◆ FLT_PINFTY

#define FLT_PINFTY (3.40282347e+38F)

Definition at line 1403 of file stdsoap2.h.

◆ GSOAP_VERSION

#define GSOAP_VERSION 208105

Definition at line 55 of file stdsoap2.h.

◆ HAVE_ASCTIME_R

#define HAVE_ASCTIME_R

Definition at line 574 of file stdsoap2.h.

◆ HAVE_GETHOSTBYNAME_R

#define HAVE_GETHOSTBYNAME_R

Definition at line 572 of file stdsoap2.h.

◆ HAVE_GETTIMEOFDAY

#define HAVE_GETTIMEOFDAY

Definition at line 570 of file stdsoap2.h.

◆ HAVE_GMTIME_R

#define HAVE_GMTIME_R

Definition at line 573 of file stdsoap2.h.

◆ HAVE_LOCALE_H

#define HAVE_LOCALE_H

Definition at line 577 of file stdsoap2.h.

◆ HAVE_LOCALTIME_R

#define HAVE_LOCALTIME_R

Definition at line 575 of file stdsoap2.h.

◆ HAVE_RAND_R

#define HAVE_RAND_R

Definition at line 571 of file stdsoap2.h.

◆ HAVE_SNPRINTF

#define HAVE_SNPRINTF

Definition at line 562 of file stdsoap2.h.

◆ HAVE_SSCANF

#define HAVE_SSCANF

Definition at line 565 of file stdsoap2.h.

◆ HAVE_STRERROR_R

#define HAVE_STRERROR_R

Definition at line 576 of file stdsoap2.h.

◆ HAVE_STRRCHR

#define HAVE_STRRCHR

Definition at line 563 of file stdsoap2.h.

◆ HAVE_STRTOD

#define HAVE_STRTOD

Definition at line 564 of file stdsoap2.h.

◆ HAVE_STRTOL

#define HAVE_STRTOL

Definition at line 566 of file stdsoap2.h.

◆ HAVE_STRTOLL

#define HAVE_STRTOLL

Definition at line 568 of file stdsoap2.h.

◆ HAVE_STRTOUL

#define HAVE_STRTOUL

Definition at line 567 of file stdsoap2.h.

◆ HAVE_STRTOULL

#define HAVE_STRTOULL

Definition at line 569 of file stdsoap2.h.

◆ LONG64

#define LONG64 long long

Definition at line 1085 of file stdsoap2.h.

◆ SOAP_BASEREFNAME

#define SOAP_BASEREFNAME "_"

Definition at line 1256 of file stdsoap2.h.

◆ SOAP_BEGIN_RECV

#define SOAP_BEGIN_RECV 2

Definition at line 1778 of file stdsoap2.h.

◆ SOAP_BEGIN_SEND

#define SOAP_BEGIN_SEND 1

Definition at line 1777 of file stdsoap2.h.

◆ SOAP_BINARY_BUFLEN

#define SOAP_BINARY_BUFLEN (128)

Definition at line 631 of file stdsoap2.h.

◆ SOAP_BLKLEN

#define SOAP_BLKLEN (256) /* to collect long strings and XML attributes */

Definition at line 1197 of file stdsoap2.h.

◆ SOAP_BUFLEN

#define SOAP_BUFLEN (65536) /* buffer length for socket packets, so don't make this too small */

Definition at line 1170 of file stdsoap2.h.

◆ SOAP_C_MBSTRING

#define SOAP_C_MBSTRING 0x04000000 /* (de)serialize strings with multi-byte content */

Definition at line 1726 of file stdsoap2.h.

◆ SOAP_C_NILSTRING

#define SOAP_C_NILSTRING 0x08000000 /* serialize empty strings as nil (omitted) */

Definition at line 1727 of file stdsoap2.h.

◆ SOAP_C_NOIOB

#define SOAP_C_NOIOB 0x01000000 /* don't fault on array index out of bounds (just ignore) */

Definition at line 1724 of file stdsoap2.h.

◆ SOAP_C_UTFSTRING

#define SOAP_C_UTFSTRING 0x02000000 /* (de)serialize strings with UTF8 content */

Definition at line 1725 of file stdsoap2.h.

◆ soap_check_state

#define soap_check_state ( soap ) (!(soap) || ((soap)->state != SOAP_INIT && (soap)->state != SOAP_COPY))

Definition at line 1772 of file stdsoap2.h.

◆ SOAP_CHK_EOF

#define SOAP_CHK_EOF (soap->error ? soap->error : SOAP_EOF)

Definition at line 1012 of file stdsoap2.h.

◆ SOAP_CLI_FAULT

#define SOAP_CLI_FAULT 1

Definition at line 1529 of file stdsoap2.h.

◆ soap_closesocket

#define soap_closesocket ( n ) close(n)

Definition at line 991 of file stdsoap2.h.

◆ soap_clr_imode

#define soap_clr_imode	(	soap,
		n
	)	((soap)->imode &= ~(n))

Definition at line 3066 of file stdsoap2.h.

◆ soap_clr_mode

#define soap_clr_mode	(	soap,
		n
	)	((soap)->mode &= ~(n), (soap)->imode &= ~(n), (soap)->omode &= ~(n))

Definition at line 3070 of file stdsoap2.h.

◆ soap_clr_omode

#define soap_clr_omode	(	soap,
		n
	)	((soap)->omode &= ~(n))

Definition at line 3068 of file stdsoap2.h.

◆ SOAP_CMAC

#define SOAP_CMAC

Definition at line 137 of file stdsoap2.h.

◆ SOAP_CONNECT

#define SOAP_CONNECT 2008 /* CONNECT request */

Definition at line 1667 of file stdsoap2.h.

◆ SOAP_COPY

#define SOAP_COPY 2

Definition at line 1770 of file stdsoap2.h.

◆ SOAP_DATAENCODINGUNKNOWN

#define SOAP_DATAENCODINGUNKNOWN 41 /* unused */

Definition at line 1569 of file stdsoap2.h.

◆ SOAP_DEL

#define SOAP_DEL 2005 /* DELETE request */

Definition at line 1664 of file stdsoap2.h.

◆ SOAP_DEL_METHOD

#define SOAP_DEL_METHOD 18

Definition at line 1546 of file stdsoap2.h.

◆ SOAP_DELETE

#define SOAP_DELETE	(	soap,
		obj,
		type
	)	delete obj

Definition at line 1881 of file stdsoap2.h.

◆ SOAP_DELETE_ARRAY

#define SOAP_DELETE_ARRAY	(	soap,
		obj,
		type
	)	delete[] obj

Definition at line 1885 of file stdsoap2.h.

◆ SOAP_DELETE_UNMANAGED

#define SOAP_DELETE_UNMANAGED ( soap ) delete soap

Definition at line 1893 of file stdsoap2.h.

◆ soap_destroy

#define soap_destroy ( soap ) soap_delete((soap), NULL)

Definition at line 3071 of file stdsoap2.h.

◆ SOAP_DIME_ABSURI

#define SOAP_DIME_ABSURI 0x20

Definition at line 1676 of file stdsoap2.h.

◆ SOAP_DIME_CF

#define SOAP_DIME_CF 0x01

Definition at line 1671 of file stdsoap2.h.

◆ SOAP_DIME_END

#define SOAP_DIME_END 35

Definition at line 1563 of file stdsoap2.h.

◆ SOAP_DIME_ERROR

#define SOAP_DIME_ERROR 32

Definition at line 1560 of file stdsoap2.h.

◆ soap_dime_error_check

#define soap_dime_error_check ( e )

Value:

  ((e) == SOAP_DIME_ERROR || \
   (e) == SOAP_DIME_HREF || \
   (e) == SOAP_DIME_MISMATCH || \
   (e) == SOAP_DIME_END)

Definition at line 1621 of file stdsoap2.h.

◆ SOAP_DIME_HREF

#define SOAP_DIME_HREF 33

Definition at line 1561 of file stdsoap2.h.

◆ SOAP_DIME_MB

#define SOAP_DIME_MB 0x04

Definition at line 1673 of file stdsoap2.h.

◆ SOAP_DIME_ME

#define SOAP_DIME_ME 0x02

Definition at line 1672 of file stdsoap2.h.

◆ SOAP_DIME_MEDIA

#define SOAP_DIME_MEDIA 0x10

Definition at line 1675 of file stdsoap2.h.

◆ SOAP_DIME_MISMATCH

#define SOAP_DIME_MISMATCH 34

Definition at line 1562 of file stdsoap2.h.

◆ SOAP_DIME_VERSION

#define SOAP_DIME_VERSION 0x08 /* DIME version 1 */

Definition at line 1674 of file stdsoap2.h.

◆ SOAP_DOM_ASIS

#define SOAP_DOM_ASIS 0x00400000

Definition at line 1720 of file stdsoap2.h.

◆ SOAP_DOM_NODE

#define SOAP_DOM_NODE 0x00200000

Definition at line 1719 of file stdsoap2.h.

◆ SOAP_DOM_TREE

#define SOAP_DOM_TREE 0x00100000 /* see DOM manual */

Definition at line 1718 of file stdsoap2.h.

◆ SOAP_DUPLICATE_ID

#define SOAP_DUPLICATE_ID 24

Definition at line 1552 of file stdsoap2.h.

◆ SOAP_EADDRINUSE

#define SOAP_EADDRINUSE EADDRINUSE

Definition at line 1135 of file stdsoap2.h.

◆ SOAP_EAGAIN

#define SOAP_EAGAIN EAGAIN

Definition at line 1134 of file stdsoap2.h.

◆ SOAP_ECONNREFUSED

#define SOAP_ECONNREFUSED ECONNREFUSED

Definition at line 1136 of file stdsoap2.h.

◆ SOAP_EINPROGRESS

#define SOAP_EINPROGRESS EINPROGRESS

Definition at line 1142 of file stdsoap2.h.

◆ SOAP_EINTR

#define SOAP_EINTR EINTR

Definition at line 1133 of file stdsoap2.h.

◆ SOAP_EMPTY

#define SOAP_EMPTY 52

Definition at line 1580 of file stdsoap2.h.

◆ SOAP_ENC

#define SOAP_ENC 0x00000FFF /* IO and ENC mask */

Definition at line 1699 of file stdsoap2.h.

◆ SOAP_ENC_DIME

#define SOAP_ENC_DIME 0x00000080

Definition at line 1703 of file stdsoap2.h.

◆ SOAP_ENC_LATIN

#define SOAP_ENC_LATIN 0x00000020 /* in: accept iso-8859-1 */

Definition at line 1700 of file stdsoap2.h.

◆ SOAP_ENC_MIME

#define SOAP_ENC_MIME 0x00000100

Definition at line 1704 of file stdsoap2.h.

◆ SOAP_ENC_MTOM

#define SOAP_ENC_MTOM 0x00000200

Definition at line 1705 of file stdsoap2.h.

◆ SOAP_ENC_PLAIN

#define SOAP_ENC_PLAIN 0x00000040 /* out: plain (XML or other) body, no HTTP header */

Definition at line 1701 of file stdsoap2.h.

◆ SOAP_ENC_SSL

#define SOAP_ENC_SSL 0x00000800

Definition at line 1707 of file stdsoap2.h.

◆ SOAP_ENC_XML

#define SOAP_ENC_XML 0x00000040 /* deprecated, alias for SOAP_ENC_PLAIN */

Definition at line 1702 of file stdsoap2.h.

◆ SOAP_ENC_ZLIB

#define SOAP_ENC_ZLIB 0x00000400

Definition at line 1706 of file stdsoap2.h.

◆ SOAP_END

#define SOAP_END 0

Definition at line 1776 of file stdsoap2.h.

◆ SOAP_END_BODY

#define SOAP_END_BODY 8

Definition at line 1784 of file stdsoap2.h.

◆ SOAP_END_ENVELOPE

#define SOAP_END_ENVELOPE 9

Definition at line 1785 of file stdsoap2.h.

◆ SOAP_END_HEADER

#define SOAP_END_HEADER 5

Definition at line 1781 of file stdsoap2.h.

◆ SOAP_END_TAG

#define SOAP_END_TAG 53

Definition at line 1581 of file stdsoap2.h.

◆ SOAP_EOF

#define SOAP_EOF EOF

Definition at line 1527 of file stdsoap2.h.

◆ SOAP_EOM

#define SOAP_EOM 20

Definition at line 1548 of file stdsoap2.h.

◆ SOAP_ERANGE

#define SOAP_ERANGE (34)

Definition at line 1131 of file stdsoap2.h.

◆ SOAP_ERR

#define SOAP_ERR 99

Definition at line 1582 of file stdsoap2.h.

◆ soap_errno

#define soap_errno errno

Definition at line 1158 of file stdsoap2.h.

◆ SOAP_EWOULDBLOCK

#define SOAP_EWOULDBLOCK EWOULDBLOCK

Definition at line 1141 of file stdsoap2.h.

◆ SOAP_FATAL_ERROR

#define SOAP_FATAL_ERROR 11 /* deprecated */

Definition at line 1539 of file stdsoap2.h.

◆ SOAP_FAULT

#define SOAP_FAULT 12

Definition at line 1540 of file stdsoap2.h.

◆ SOAP_FD_EXCEEDED

#define SOAP_FD_EXCEEDED 47

Definition at line 1575 of file stdsoap2.h.

◆ SOAP_FILE

#define SOAP_FILE 1200 /* Custom file-based response with soap::http_content and optional http status */

Definition at line 1653 of file stdsoap2.h.

◆ SOAP_FIXED

#define SOAP_FIXED 51

Definition at line 1579 of file stdsoap2.h.

◆ SOAP_FMAC1

#define SOAP_FMAC1

Definition at line 105 of file stdsoap2.h.

◆ SOAP_FMAC2

#define SOAP_FMAC2

Definition at line 109 of file stdsoap2.h.

◆ SOAP_FMAC3

#define SOAP_FMAC3

Definition at line 113 of file stdsoap2.h.

◆ SOAP_FMAC3S

#define SOAP_FMAC3S SOAP_FMAC3

Definition at line 117 of file stdsoap2.h.

◆ SOAP_FMAC4

#define SOAP_FMAC4

Definition at line 121 of file stdsoap2.h.

◆ SOAP_FMAC4S

#define SOAP_FMAC4S SOAP_FMAC4

Definition at line 125 of file stdsoap2.h.

◆ SOAP_FMAC5

#define SOAP_FMAC5

Definition at line 129 of file stdsoap2.h.

◆ SOAP_FMAC6

#define SOAP_FMAC6

Definition at line 133 of file stdsoap2.h.

◆ SOAP_FORM

#define SOAP_FORM 1001 /* Request (form) data is present, no HTTP response should follow */

Definition at line 1651 of file stdsoap2.h.

◆ SOAP_FREE

#define SOAP_FREE	(	soap,
		ptr
	)	free((void*)(ptr))

Definition at line 1824 of file stdsoap2.h.

◆ SOAP_FREE_UNMANAGED

#define SOAP_FREE_UNMANAGED ( ptr ) free((void*)(ptr))

Definition at line 1832 of file stdsoap2.h.

◆ SOAP_FUNC_R_ERR

#define SOAP_FUNC_R_ERR (NULL)

Definition at line 982 of file stdsoap2.h.

◆ SOAP_GAI_STRERROR

#define SOAP_GAI_STRERROR gai_strerror

Definition at line 1002 of file stdsoap2.h.

◆ SOAP_GET

#define SOAP_GET 2002 /* GET request */

Definition at line 1661 of file stdsoap2.h.

◆ soap_get0

#define soap_get0 ( soap ) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx])

Definition at line 3039 of file stdsoap2.h.

◆ soap_get1

#define soap_get1 ( soap ) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx++])

Definition at line 3040 of file stdsoap2.h.

◆ SOAP_GET_METHOD

#define SOAP_GET_METHOD 15

Definition at line 1543 of file stdsoap2.h.

◆ SOAP_HDR

#define SOAP_HDR 22

Definition at line 1550 of file stdsoap2.h.

◆ SOAP_HDRLEN

#define SOAP_HDRLEN (8192) /* maximum length of HTTP header line (must be >=4096 to read cookies) */

Definition at line 1211 of file stdsoap2.h.

◆ SOAP_HEAD

#define SOAP_HEAD 2006 /* HEAD request */

Definition at line 1665 of file stdsoap2.h.

◆ SOAP_HREF

#define SOAP_HREF 26

Definition at line 1554 of file stdsoap2.h.

◆ SOAP_HTML

#define SOAP_HTML 1002 /* Custom HTML response */

Definition at line 1652 of file stdsoap2.h.

◆ SOAP_HTTP_ERROR

#define SOAP_HTTP_ERROR 29

Definition at line 1557 of file stdsoap2.h.

◆ soap_http_error_check

#define soap_http_error_check ( e )

Value:

  ((e) == SOAP_HTTP_ERROR || \
   (e) == SOAP_NO_DATA || \
   ((e) >= SOAP_GET_METHOD && (e) <= SOAP_HTTP_METHOD) || \
   ((e) >= 100 && (e) < 600))

Definition at line 1615 of file stdsoap2.h.

◆ SOAP_HTTP_METHOD

#define SOAP_HTTP_METHOD 19

Definition at line 1547 of file stdsoap2.h.

◆ SOAP_IDHASH

#define SOAP_IDHASH (1999) /* 1999, 8191: prime size of hash table for parsed id/ref */

Definition at line 1190 of file stdsoap2.h.

◆ soap_imode

#define soap_imode	(	soap,
		n
	)	((soap)->imode = (n))

Definition at line 3063 of file stdsoap2.h.

◆ SOAP_IN_BODY

#define SOAP_IN_BODY 7

Definition at line 1783 of file stdsoap2.h.

◆ SOAP_IN_ENVELOPE

#define SOAP_IN_ENVELOPE 3

Definition at line 1779 of file stdsoap2.h.

◆ SOAP_IN_HEADER

#define SOAP_IN_HEADER 4

Definition at line 1780 of file stdsoap2.h.

◆ SOAP_INDEX_RECV

#define SOAP_INDEX_RECV (0)

Definition at line 1244 of file stdsoap2.h.

◆ SOAP_INDEX_SENT

#define SOAP_INDEX_SENT (1)

Definition at line 1245 of file stdsoap2.h.

◆ SOAP_INDEX_TEST

#define SOAP_INDEX_TEST (2)

Definition at line 1246 of file stdsoap2.h.

◆ SOAP_INIT

#define SOAP_INIT 1

Definition at line 1769 of file stdsoap2.h.

◆ soap_init

#define soap_init ( soap ) soap_init1(soap, SOAP_IO_DEFAULT)

Definition at line 3050 of file stdsoap2.h.

◆ soap_init1

#define soap_init1	(	soap,
		mode
	)	soap_init2(soap, mode, mode)

Definition at line 3051 of file stdsoap2.h.

◆ soap_init2

#define soap_init2	(	soap,
		imode,
		omode
	)	soap_versioning(soap_init)(soap, imode, omode)

Definition at line 3052 of file stdsoap2.h.

◆ soap_int32

#define soap_int32 int32_t

Definition at line 1116 of file stdsoap2.h.

◆ SOAP_INVALID_SOCKET

#define SOAP_INVALID_SOCKET ((SOAP_SOCKET)-1)

Definition at line 995 of file stdsoap2.h.

◆ SOAP_IO

#define SOAP_IO 0x00000003 /* IO mask */

Definition at line 1689 of file stdsoap2.h.

◆ SOAP_IO_BUFFER

#define SOAP_IO_BUFFER 0x00000001 /* out: buffer output in packets of size SOAP_BUFLEN */

Definition at line 1691 of file stdsoap2.h.

◆ SOAP_IO_CHUNK

#define SOAP_IO_CHUNK 0x00000003 /* out: use HTTP chunked transfer AND buffer packets */

Definition at line 1693 of file stdsoap2.h.

◆ SOAP_IO_DEFAULT

#define SOAP_IO_DEFAULT SOAP_IO_FLUSH

Definition at line 1740 of file stdsoap2.h.

◆ SOAP_IO_FLUSH

#define SOAP_IO_FLUSH 0x00000000 /* out: flush output immediately, no buffering */

Definition at line 1690 of file stdsoap2.h.

◆ SOAP_IO_KEEPALIVE

#define SOAP_IO_KEEPALIVE 0x00000010 /* out: keep connection alive */

Definition at line 1697 of file stdsoap2.h.

◆ SOAP_IO_LENGTH

#define SOAP_IO_LENGTH 0x00000008 /* out: calc message length (internal) */

Definition at line 1696 of file stdsoap2.h.

◆ SOAP_IO_STORE

#define SOAP_IO_STORE 0x00000002 /* out: store entire output to determine length for transport */

Definition at line 1692 of file stdsoap2.h.

◆ SOAP_IO_UDP

#define SOAP_IO_UDP 0x00000004 /* in/out: enable UDP instead of TCP */

Definition at line 1695 of file stdsoap2.h.

◆ SOAP_IOB

#define SOAP_IOB 7

Definition at line 1535 of file stdsoap2.h.

◆ soap_isinf

#define soap_isinf ( n ) (!soap_isnan(n) && soap_isnan((n) - (n)))

Definition at line 1447 of file stdsoap2.h.

◆ soap_isnan

#define soap_isnan ( n ) ((n) != (n))

Definition at line 1439 of file stdsoap2.h.

◆ soap_isninfd

#define soap_isninfd ( n ) ((n) < 0 && soap_isinf(n))

Definition at line 1453 of file stdsoap2.h.

◆ soap_isninff

#define soap_isninff ( n ) ((n) < 0 && soap_isinf(n))

Definition at line 1454 of file stdsoap2.h.

◆ soap_ispinfd

#define soap_ispinfd ( n ) ((n) > 0 && soap_isinf(n))

Definition at line 1451 of file stdsoap2.h.

◆ soap_ispinff

#define soap_ispinff ( n ) ((n) > 0 && soap_isinf(n))

Definition at line 1452 of file stdsoap2.h.

◆ SOAP_LABLEN

#define SOAP_LABLEN (256) /* initial look-aside buffer length */

Definition at line 1176 of file stdsoap2.h.

◆ SOAP_LENGTH

#define SOAP_LENGTH 45

Definition at line 1573 of file stdsoap2.h.

◆ SOAP_LEVEL

#define SOAP_LEVEL 50

Definition at line 1578 of file stdsoap2.h.

◆ SOAP_LONG_FORMAT

#define SOAP_LONG_FORMAT "%lld" /* printf format for 64 bit long long ints */

Definition at line 1098 of file stdsoap2.h.

◆ SOAP_MALLOC

#define SOAP_MALLOC	(	soap,
		size
	)	malloc((size))

Definition at line 1820 of file stdsoap2.h.

◆ SOAP_MALLOC_UNMANAGED

#define SOAP_MALLOC_UNMANAGED ( size ) malloc((size))

Definition at line 1828 of file stdsoap2.h.

◆ SOAP_MAXALLOCSIZE

#define SOAP_MAXALLOCSIZE (0) /* max size that malloc() can handle, zero for no limit */

Definition at line 1239 of file stdsoap2.h.

◆ SOAP_MAXARRAYSIZE

#define SOAP_MAXARRAYSIZE (100000)

Definition at line 1276 of file stdsoap2.h.

◆ SOAP_MAXDIMESIZE

#define SOAP_MAXDIMESIZE (8*1048576) /* 8 MB */

Definition at line 1285 of file stdsoap2.h.

◆ SOAP_MAXDIMS

#define SOAP_MAXDIMS (16) /* maximum array dimensions (array nestings) must be less than 64 to protect soap->tmpbuf */

Definition at line 1225 of file stdsoap2.h.

◆ SOAP_MAXEINTR

#define SOAP_MAXEINTR (10)

Definition at line 1262 of file stdsoap2.h.

◆ SOAP_MAXINFLATESIZE

#define SOAP_MAXINFLATESIZE (1*1048576) /* 1 MB */

Definition at line 1294 of file stdsoap2.h.

◆ SOAP_MAXKEEPALIVE

#define SOAP_MAXKEEPALIVE (100)

Definition at line 1267 of file stdsoap2.h.

◆ SOAP_MAXLENGTH

#define SOAP_MAXLENGTH (0)

Definition at line 1318 of file stdsoap2.h.

◆ SOAP_MAXLEVEL

#define SOAP_MAXLEVEL (10000)

Definition at line 1313 of file stdsoap2.h.

◆ SOAP_MAXLOGS

#define SOAP_MAXLOGS (3) /* max number of debug logs per struct soap environment */

Definition at line 1243 of file stdsoap2.h.

◆ SOAP_MAXOCCURS

#define SOAP_MAXOCCURS (100000)

Definition at line 1323 of file stdsoap2.h.

◆ SOAP_MAXPTRS

#define SOAP_MAXPTRS (4) /* maximum depth + 1 of id-ref deserialized pointer types (int* has depth 0, int*** has depth 2) */

Definition at line 1232 of file stdsoap2.h.

◆ soap_memcpy

#define soap_memcpy	(	buf,
		len,
		src,
		num
	)	((size_t)(len) >= (size_t)(num) ? !memcpy((buf), (src), (num)) : SOAP_ERANGE)

Definition at line 1513 of file stdsoap2.h.

◆ soap_memmove

#define soap_memmove	(	buf,
		len,
		src,
		num
	)	((size_t)(len) >= (size_t)(num) ? !memmove((buf), (src), (num)) : SOAP_ERANGE)

Definition at line 1520 of file stdsoap2.h.

◆ SOAP_MIME_END

#define SOAP_MIME_END 38

Definition at line 1566 of file stdsoap2.h.

◆ SOAP_MIME_ERROR

#define SOAP_MIME_ERROR 36

Definition at line 1564 of file stdsoap2.h.

◆ soap_mime_error_check

#define soap_mime_error_check ( e )

Value:

  ((e) == SOAP_MIME_ERROR || \
   (e) == SOAP_MIME_HREF || \
   (e) == SOAP_MIME_END)

Definition at line 1627 of file stdsoap2.h.

◆ SOAP_MIME_HREF

#define SOAP_MIME_HREF 37

Definition at line 1565 of file stdsoap2.h.

◆ SOAP_MIME_POSTCHECK

#define SOAP_MIME_POSTCHECK 0x40000000 /* MIME flag (internal) */

Definition at line 1732 of file stdsoap2.h.

◆ SOAP_MINDEFLATERATIO

#define SOAP_MINDEFLATERATIO (1.0/1032.0) /* ratio of deflated/inflated */

Definition at line 1308 of file stdsoap2.h.

◆ SOAP_MISSING_ID

#define SOAP_MISSING_ID 25

Definition at line 1553 of file stdsoap2.h.

◆ soap_mode

#define soap_mode	(	soap,
		n
	)	((soap)->mode = (soap)->imode = (soap)->omode = (n))

Definition at line 3062 of file stdsoap2.h.

◆ SOAP_MOE

#define SOAP_MOE 21

Definition at line 1549 of file stdsoap2.h.

◆ SOAP_MULTIREFTAG

#define SOAP_MULTIREFTAG "id"

Definition at line 1251 of file stdsoap2.h.

◆ SOAP_MUSTUNDERSTAND

#define SOAP_MUSTUNDERSTAND 8

Definition at line 1536 of file stdsoap2.h.

◆ SOAP_NAMESPACE

#define SOAP_NAMESPACE 9

Definition at line 1537 of file stdsoap2.h.

◆ soap_new

#define soap_new ( ) soap_new1(SOAP_IO_DEFAULT)

Definition at line 3054 of file stdsoap2.h.

◆ SOAP_NEW

#define SOAP_NEW	(	soap,
		type
	)	new SOAP_NOTHROW (type)

Definition at line 1870 of file stdsoap2.h.

◆ soap_new1

#define soap_new1 ( mode ) soap_new2(mode, mode)

Definition at line 3055 of file stdsoap2.h.

◆ soap_new2

#define soap_new2	(	imode,
		omode
	)	soap_versioning(soap_new)(imode, omode)

Definition at line 3056 of file stdsoap2.h.

◆ SOAP_NEW_ARRAY

#define SOAP_NEW_ARRAY	(	soap,
		type,
		n
	)	new SOAP_NOTHROW type[n]

Definition at line 1873 of file stdsoap2.h.

◆ SOAP_NEW_UNMANAGED

#define SOAP_NEW_UNMANAGED ( soap ) new SOAP_NOTHROW soap

Definition at line 1889 of file stdsoap2.h.

◆ SOAP_NMAC

#define SOAP_NMAC

Definition at line 141 of file stdsoap2.h.

◆ SOAP_NO_BODY

#define SOAP_NO_BODY 6

Definition at line 1782 of file stdsoap2.h.

◆ SOAP_NO_DATA

#define SOAP_NO_DATA 14

Definition at line 1542 of file stdsoap2.h.

◆ SOAP_NO_LINK_TO_DELETE

#define SOAP_NO_LINK_TO_DELETE (-2) /* pass to soap_link() as size n: do not manage, smart pointers are self-managing */

Definition at line 3073 of file stdsoap2.h.

◆ SOAP_NO_METHOD

#define SOAP_NO_METHOD 13

Definition at line 1541 of file stdsoap2.h.

◆ SOAP_NO_TAG

#define SOAP_NO_TAG 6

Definition at line 1534 of file stdsoap2.h.

◆ SOAP_NONE

#define SOAP_NONE 0

Definition at line 1768 of file stdsoap2.h.

◆ SOAP_NOTHROW

#define SOAP_NOTHROW (std::nothrow)

Definition at line 1841 of file stdsoap2.h.

◆ SOAP_NTLM_ERROR

#define SOAP_NTLM_ERROR 49

Definition at line 1577 of file stdsoap2.h.

◆ SOAP_NULL

#define SOAP_NULL 23

Definition at line 1551 of file stdsoap2.h.

◆ SOAP_OCCURS

#define SOAP_OCCURS 44

Definition at line 1572 of file stdsoap2.h.

◆ SOAP_OK

#define SOAP_OK 0

Definition at line 1528 of file stdsoap2.h.

◆ soap_omode

#define soap_omode	(	soap,
		n
	)	((soap)->omode = (n))

Definition at line 3064 of file stdsoap2.h.

◆ SOAP_OPTIONS

#define SOAP_OPTIONS 2007 /* OPTIONS request */

Definition at line 1666 of file stdsoap2.h.

◆ SOAP_PATCH

#define SOAP_PATCH 2004 /* PATCH request */

Definition at line 1663 of file stdsoap2.h.

◆ SOAP_PATCH_METHOD

#define SOAP_PATCH_METHOD 17

Definition at line 1545 of file stdsoap2.h.

◆ SOAP_PATTERN

#define SOAP_PATTERN 46

Definition at line 1574 of file stdsoap2.h.

◆ soap_peek

#define soap_peek ( soap ) ((soap)->ahead = soap_get(soap))

Definition at line 3060 of file stdsoap2.h.

◆ SOAP_PLACEMENT_NEW

#define SOAP_PLACEMENT_NEW	(	soap,
		buf,
		type
	)	new (buf) (type)

Definition at line 1876 of file stdsoap2.h.

◆ SOAP_PLUGIN_ERROR

#define SOAP_PLUGIN_ERROR 40

Definition at line 1568 of file stdsoap2.h.

◆ SOAP_POST

#define SOAP_POST 2000 /* POST request */

Definition at line 1659 of file stdsoap2.h.

◆ SOAP_POST_FILE

#define SOAP_POST_FILE 2001 /* Custom file-based POST request */

Definition at line 1660 of file stdsoap2.h.

◆ SOAP_PROHIBITED

#define SOAP_PROHIBITED 43

Definition at line 1571 of file stdsoap2.h.

◆ SOAP_PTRBLK

#define SOAP_PTRBLK (32) /* block allocation for pointer hash table chains */

Definition at line 1179 of file stdsoap2.h.

◆ SOAP_PTRHASH

#define SOAP_PTRHASH (4096) /* size of pointer analysis hash table (must be power of 2) */

Definition at line 1183 of file stdsoap2.h.

◆ SOAP_PURE_VIRTUAL

#define SOAP_PURE_VIRTUAL

Definition at line 618 of file stdsoap2.h.

◆ SOAP_PURE_VIRTUAL_COPY

#define SOAP_PURE_VIRTUAL_COPY

Definition at line 619 of file stdsoap2.h.

◆ SOAP_PUT

#define SOAP_PUT 2003 /* PUT request */

Definition at line 1662 of file stdsoap2.h.

◆ SOAP_PUT_METHOD

#define SOAP_PUT_METHOD 16

Definition at line 1544 of file stdsoap2.h.

◆ soap_random

#define soap_random rand()

Definition at line 3117 of file stdsoap2.h.

◆ soap_register_plugin

#define soap_register_plugin	(	soap,
		plugin
	)	soap_register_plugin_arg(soap, plugin, NULL)

Definition at line 3061 of file stdsoap2.h.

◆ SOAP_REQUIRED

#define SOAP_REQUIRED 42

Definition at line 1570 of file stdsoap2.h.

◆ soap_reset_errno

#define soap_reset_errno (errno = ENOENT)

Definition at line 1160 of file stdsoap2.h.

◆ soap_revget1

#define soap_revget1 ( soap ) ((soap)->bufidx--)

Definition at line 3058 of file stdsoap2.h.

◆ SOAP_SEC_BEGIN

#define SOAP_SEC_BEGIN 1

Definition at line 1789 of file stdsoap2.h.

◆ SOAP_SEC_DECRYPT

#define SOAP_SEC_DECRYPT 3

Definition at line 1791 of file stdsoap2.h.

◆ SOAP_SEC_SIGN

#define SOAP_SEC_SIGN 2

Definition at line 1790 of file stdsoap2.h.

◆ SOAP_SEC_WSUID

#define SOAP_SEC_WSUID 0x80000000 /* Add Body wsu:Id flag (internal) */

Definition at line 1734 of file stdsoap2.h.

◆ soap_set_imode

#define soap_set_imode	(	soap,
		n
	)	((soap)->imode \|= (n))

Definition at line 3065 of file stdsoap2.h.

◆ soap_set_mode

#define soap_set_mode	(	soap,
		n
	)	((soap)->mode \|= (n), (soap)->imode \|= (n), (soap)->omode \|= (n))

Definition at line 3069 of file stdsoap2.h.

◆ soap_set_omode

#define soap_set_omode	(	soap,
		n
	)	((soap)->omode \|= (n))

Definition at line 3067 of file stdsoap2.h.

◆ SOAP_SHUT_RDWR

#define SOAP_SHUT_RDWR (2)

Definition at line 999 of file stdsoap2.h.

◆ SOAP_SHUT_WR

#define SOAP_SHUT_WR (1)

Definition at line 998 of file stdsoap2.h.

◆ SOAP_SNPRINTF

#define SOAP_SNPRINTF	(	buf,
		len,
		num
	)	void)snprintf((buf), (len)

Definition at line 1469 of file stdsoap2.h.

◆ SOAP_SNPRINTF_SAFE

#define SOAP_SNPRINTF_SAFE	(	buf,
		len
	)	void)snprintf((buf), (len)

Definition at line 1470 of file stdsoap2.h.

◆ soap_soap_error_check

#define soap_soap_error_check ( e )

Value:

  ((e) == SOAP_CLI_FAULT || \
   (e) == SOAP_SVR_FAULT || \
   (e) == SOAP_VERSIONMISMATCH || \
   (e) == SOAP_MUSTUNDERSTAND || \
   (e) == SOAP_FAULT || \
   (e) == SOAP_NO_METHOD || \
   (e) == SOAP_DATAENCODINGUNKNOWN)

Definition at line 1606 of file stdsoap2.h.

◆ SOAP_SOCKET

#define SOAP_SOCKET int

Definition at line 990 of file stdsoap2.h.

◆ soap_socket_errno

#define soap_socket_errno errno

Definition at line 1159 of file stdsoap2.h.

◆ SOAP_SOCKLEN_T

#define SOAP_SOCKLEN_T socklen_t

Definition at line 971 of file stdsoap2.h.

◆ SOAP_SOURCE_STAMP

#define SOAP_SOURCE_STAMP ( str )

Definition at line 145 of file stdsoap2.h.

◆ SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE

#define SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE (0x0008) /* allow self-signed and expired certificates and those w/o CRL */

Definition at line 1749 of file stdsoap2.h.

◆ SOAP_SSL_CLIENT

#define SOAP_SSL_CLIENT (0x8000) /* client context flag for internal use */

Definition at line 1760 of file stdsoap2.h.

◆ SOAP_SSL_DEFAULT

#define SOAP_SSL_DEFAULT SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION

Definition at line 1762 of file stdsoap2.h.

◆ SOAP_SSL_ERROR

#define SOAP_SSL_ERROR 30

Definition at line 1558 of file stdsoap2.h.

◆ soap_ssl_error_check

#define soap_ssl_error_check ( e ) ((e) == SOAP_SSL_ERROR)

Definition at line 1640 of file stdsoap2.h.

◆ SOAP_SSL_NO_AUTHENTICATION

#define SOAP_SSL_NO_AUTHENTICATION (0x0000) /* no authentication */

Definition at line 1745 of file stdsoap2.h.

◆ SOAP_SSL_NO_DEFAULT_CA_PATH

#define SOAP_SSL_NO_DEFAULT_CA_PATH (0x0010) /* don't use SSL_CTX_set_default_verify_paths */

Definition at line 1750 of file stdsoap2.h.

◆ SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION

#define SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION (0x0002) /* server requires client to authenticate */

Definition at line 1747 of file stdsoap2.h.

◆ SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION

#define SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION (0x0001) /* client requires server to authenticate */

Definition at line 1746 of file stdsoap2.h.

◆ SOAP_SSL_RSA

#define SOAP_SSL_RSA (0x0020) /* use RSA */

Definition at line 1751 of file stdsoap2.h.

◆ SOAP_SSL_SKIP_HOST_CHECK

#define SOAP_SSL_SKIP_HOST_CHECK (0x0004) /* client skips common name check against host name */

Definition at line 1748 of file stdsoap2.h.

◆ SOAP_SSLv3

#define SOAP_SSLv3 (0x0080) /* enable SSL v3 */

Definition at line 1752 of file stdsoap2.h.

◆ SOAP_SSLv3_TLSv1

#define SOAP_SSLv3_TLSv1 (SOAP_SSLv3 | SOAP_TLSv1)

Definition at line 1758 of file stdsoap2.h.

◆ SOAP_STOP

#define SOAP_STOP 1000 /* No HTTP response should follow after SOAP_STOP is issued */

Definition at line 1650 of file stdsoap2.h.

◆ SOAP_STRCMP

#define SOAP_STRCMP strcmp /* case sensitive XML element/attribute names */

Definition at line 944 of file stdsoap2.h.

◆ soap_strcpy

#define soap_strcpy	(	buf,
		len,
		src
	)	(void)(strncpy((buf), (src), (len)), (buf)[(len) - 1] = '\0')

Definition at line 1483 of file stdsoap2.h.

◆ SOAP_STRINGIFY

#define SOAP_STRINGIFY ( s ) #s

Definition at line 152 of file stdsoap2.h.

◆ soap_strncpy

#define soap_strncpy	(	buf,
		len,
		src,
		num
	)	((buf) == NULL \|\| ((size_t)(len) > (size_t)(num) ? (strncpy((buf), (src), (num)), (buf)[(size_t)(num)] = '\0') : ((buf)[0] = '\0', 1)))

Definition at line 1499 of file stdsoap2.h.

◆ soap_strrchr

#define soap_strrchr	(	s,
		t
	)	strrchr(s, t)

Definition at line 3076 of file stdsoap2.h.

◆ soap_strtol

#define soap_strtol	(	s,
		t,
		b
	)	strtol(s, t, b)

Definition at line 3082 of file stdsoap2.h.

◆ soap_strtoll

#define soap_strtoll strtoll

Definition at line 3096 of file stdsoap2.h.

◆ soap_strtoul

#define soap_strtoul	(	s,
		t,
		b
	)	strtoul(s, t, b)

Definition at line 3088 of file stdsoap2.h.

◆ soap_strtoull

#define soap_strtoull strtoull

Definition at line 3104 of file stdsoap2.h.

◆ SOAP_SVR_FAULT

#define SOAP_SVR_FAULT 2

Definition at line 1530 of file stdsoap2.h.

◆ SOAP_SYNTAX_ERROR

#define SOAP_SYNTAX_ERROR 5

Definition at line 1533 of file stdsoap2.h.

◆ SOAP_TAG_MISMATCH

#define SOAP_TAG_MISMATCH 3

Definition at line 1531 of file stdsoap2.h.

◆ SOAP_TAGLEN

#define SOAP_TAGLEN (1024) /* maximum length of XML element tag/attribute name or host/path name + 1 */

Definition at line 1204 of file stdsoap2.h.

◆ SOAP_TCP_ERROR

#define SOAP_TCP_ERROR 28

Definition at line 1556 of file stdsoap2.h.

◆ soap_tcp_error_check

#define soap_tcp_error_check ( e )

Value:

((e) == SOAP_EOF || \

(e) == SOAP_TCP_ERROR)

SOAP_EOF

#define SOAP_EOF

Definition: stdsoap2.h:1527

SOAP_TCP_ERROR

#define SOAP_TCP_ERROR

Definition: stdsoap2.h:1556

Definition at line 1632 of file stdsoap2.h.

◆ SOAP_TLSv1

#define SOAP_TLSv1 (SOAP_TLSv1_0 | SOAP_TLSv1_1 | SOAP_TLSv1_2 | SOAP_TLSv1_3)

Definition at line 1757 of file stdsoap2.h.

◆ SOAP_TLSv1_0

#define SOAP_TLSv1_0 (0x0100) /* enable TLS v1.0 */

Definition at line 1753 of file stdsoap2.h.

◆ SOAP_TLSv1_1

#define SOAP_TLSv1_1 (0x0200) /* enable TLS v1.1 */

Definition at line 1754 of file stdsoap2.h.

◆ SOAP_TLSv1_2

#define SOAP_TLSv1_2 (0x0400) /* enable TLS v1.2 */

Definition at line 1755 of file stdsoap2.h.

◆ SOAP_TLSv1_3

#define SOAP_TLSv1_3 (0x0800) /* enable TLS v1.3 */

Definition at line 1756 of file stdsoap2.h.

◆ SOAP_TMPLEN

#define SOAP_TMPLEN (2048) /* maximum length of msgbuf and tmpbuf short message buffers, must be >=1024 */

Definition at line 1218 of file stdsoap2.h.

◆ SOAP_TYPE

#define SOAP_TYPE 4

Definition at line 1532 of file stdsoap2.h.

◆ SOAP_UDP_ERROR

#define SOAP_UDP_ERROR 27

Definition at line 1555 of file stdsoap2.h.

◆ soap_udp_error_check

#define soap_udp_error_check ( e )

Value:

((e) == SOAP_EOF || \

(e) == SOAP_UDP_ERROR)

SOAP_UDP_ERROR

#define SOAP_UDP_ERROR

Definition: stdsoap2.h:1555

Definition at line 1636 of file stdsoap2.h.

◆ SOAP_ULONG_FORMAT

#define SOAP_ULONG_FORMAT "%llu" /* printf format for unsigned 64 bit long long ints */

Definition at line 1102 of file stdsoap2.h.

◆ soap_unget

#define soap_unget	(	soap,
		c
	)	((soap)->ahead = c)

Definition at line 3059 of file stdsoap2.h.

◆ SOAP_USER_ERROR

#define SOAP_USER_ERROR 10

Definition at line 1538 of file stdsoap2.h.

◆ SOAP_UTF_ERROR

#define SOAP_UTF_ERROR 48

Definition at line 1576 of file stdsoap2.h.

◆ soap_valid_socket

#define soap_valid_socket ( sk ) ((sk) != SOAP_INVALID_SOCKET)

Definition at line 996 of file stdsoap2.h.

◆ soap_versioning

#define soap_versioning ( name ) soap_versioning_ext(name, GSOAP_VERSION)

Definition at line 3048 of file stdsoap2.h.

◆ soap_versioning_ext

#define soap_versioning_ext	(	name,
		ext
	)	soap_versioning_paste(name, ext)

Definition at line 3047 of file stdsoap2.h.

◆ soap_versioning_paste

#define soap_versioning_paste	(	name,
		ext
	)	name##_REQUIRE_lib_v##ext

Definition at line 3046 of file stdsoap2.h.

◆ SOAP_VERSIONMISMATCH

#define SOAP_VERSIONMISMATCH 39

Definition at line 1567 of file stdsoap2.h.

◆ SOAP_WINSOCKINT

#define SOAP_WINSOCKINT size_t

Definition at line 838 of file stdsoap2.h.

◆ SOAP_XML_CANONICAL

#define SOAP_XML_CANONICAL 0x00010000 /* out: exc-C14N exclusive canonical XML */

Definition at line 1713 of file stdsoap2.h.

◆ SOAP_XML_CANONICAL_NA

#define SOAP_XML_CANONICAL_NA 0x00800000 /* out: (exc) C14N not QName aware */

Definition at line 1722 of file stdsoap2.h.

◆ SOAP_XML_DEFAULTNS

#define SOAP_XML_DEFAULTNS 0x00008000 /* out: emit xmlns="..." */

Definition at line 1712 of file stdsoap2.h.

◆ SOAP_XML_DOM

#define SOAP_XML_DOM 0x10000000 /* enable internal DOM */

Definition at line 1729 of file stdsoap2.h.

◆ soap_xml_error_check

#define soap_xml_error_check ( e )

Value:

  ((e) == SOAP_TAG_MISMATCH || \
   (e) == SOAP_NO_TAG || \
   (e) == SOAP_IOB || \
   (e) == SOAP_SYNTAX_ERROR || \
   (e) == SOAP_NAMESPACE || \
   (e) == SOAP_TYPE || \
   (e) == SOAP_DUPLICATE_ID || \
   (e) == SOAP_MISSING_ID || \
   (e) == SOAP_REQUIRED || \
   (e) == SOAP_PROHIBITED || \
   (e) == SOAP_OCCURS || \
   (e) == SOAP_LENGTH || \
   (e) == SOAP_LEVEL || \
   (e) == SOAP_PATTERN || \
   (e) == SOAP_NULL || \
   (e) == SOAP_HREF || \
   (e) == SOAP_FIXED || \
   (e) == SOAP_EMPTY || \
   (e) == SOAP_END_TAG || \
   (e) == SOAP_UTF_ERROR)

Definition at line 1584 of file stdsoap2.h.

◆ SOAP_XML_GRAPH

#define SOAP_XML_GRAPH 0x20000000 /* force id-ref XML graph */

Definition at line 1730 of file stdsoap2.h.

◆ SOAP_XML_IGNORENS

#define SOAP_XML_IGNORENS 0x00004000 /* in: ignore namespaces */

Definition at line 1711 of file stdsoap2.h.

◆ SOAP_XML_INDENT

#define SOAP_XML_INDENT 0x00002000 /* out: emit indented XML */

Definition at line 1710 of file stdsoap2.h.

◆ SOAP_XML_NIL

#define SOAP_XML_NIL 0x00040000 /* out: all NULLs as xsi:nil */

Definition at line 1715 of file stdsoap2.h.

◆ SOAP_XML_NOTYPE

#define SOAP_XML_NOTYPE 0x00080000 /* out: do not add xsi:type */

Definition at line 1716 of file stdsoap2.h.

◆ SOAP_XML_STRICT

#define SOAP_XML_STRICT 0x00001000 /* in: strict validation */

Definition at line 1709 of file stdsoap2.h.

◆ SOAP_XML_TREE

#define SOAP_XML_TREE 0x00020000 /* in/out: XML tree (no id/ref) */

Definition at line 1714 of file stdsoap2.h.

◆ SOAP_XSTRINGIFY

#define SOAP_XSTRINGIFY ( s ) SOAP_STRINGIFY(s)

Definition at line 151 of file stdsoap2.h.

◆ SOAP_ZLIB_DEFLATE

#define SOAP_ZLIB_DEFLATE 0x01

Definition at line 1681 of file stdsoap2.h.

◆ SOAP_ZLIB_ERROR

#define SOAP_ZLIB_ERROR 31

Definition at line 1559 of file stdsoap2.h.

◆ soap_zlib_error_check

#define soap_zlib_error_check ( e ) ((e) == SOAP_ZLIB_ERROR)

Definition at line 1642 of file stdsoap2.h.

◆ SOAP_ZLIB_GZIP

#define SOAP_ZLIB_GZIP 0x02

Definition at line 1683 of file stdsoap2.h.

◆ SOAP_ZLIB_INFLATE

#define SOAP_ZLIB_INFLATE 0x02

Definition at line 1682 of file stdsoap2.h.

◆ SOAP_ZLIB_NONE

#define SOAP_ZLIB_NONE 0x00

Definition at line 1680 of file stdsoap2.h.

◆ STDSOAP_H

#define STDSOAP_H

Definition at line 149 of file stdsoap2.h.

◆ ULONG64

#define ULONG64 unsigned LONG64

Definition at line 1086 of file stdsoap2.h.

◆ WITH_CDATA

#define WITH_CDATA

Definition at line 594 of file stdsoap2.h.

◆ WITH_FAST

#define WITH_FAST

Definition at line 590 of file stdsoap2.h.

◆ WITH_NO_C_LOCALE

#define WITH_NO_C_LOCALE /* turn locale support off by default */

Definition at line 559 of file stdsoap2.h.

◆ WITH_NOEMPTYSTRUCT

#define WITH_NOEMPTYSTRUCT

Definition at line 602 of file stdsoap2.h.

Typedef Documentation

◆ soap_http_command

typedef int soap_http_command

Definition at line 1657 of file stdsoap2.h.

◆ soap_mode

typedef soap_int32 soap_mode

Definition at line 1687 of file stdsoap2.h.

◆ soap_ssl_flags

typedef unsigned short soap_ssl_flags

Definition at line 1764 of file stdsoap2.h.

◆ soap_status

typedef soap_int32 soap_status

Definition at line 1525 of file stdsoap2.h.

◆ soap_walker

typedef void soap_walker(struct soap *, void *, int, const char *, const char *)

Definition at line 3141 of file stdsoap2.h.

◆ soap_wchar

typedef soap_int32 soap_wchar

Definition at line 1994 of file stdsoap2.h.

Enumeration Type Documentation

◆ soap_mime_encoding

enum soap_mime_encoding

Enumerator
SOAP_MIME_NONE
SOAP_MIME_7BIT
SOAP_MIME_8BIT
SOAP_MIME_BINARY
SOAP_MIME_QUOTED_PRINTABLE
SOAP_MIME_BASE64
SOAP_MIME_IETF_TOKEN
SOAP_MIME_X_TOKEN

Definition at line 2176 of file stdsoap2.h.

 {
     SOAP_MIME_NONE,
     SOAP_MIME_7BIT,
     SOAP_MIME_8BIT,
     SOAP_MIME_BINARY,
     SOAP_MIME_QUOTED_PRINTABLE,
     SOAP_MIME_BASE64,
     SOAP_MIME_IETF_TOKEN,
     SOAP_MIME_X_TOKEN
 };

Function Documentation

◆ soap_accept()

SOAP_FMAC1 SOAP_SOCKET SOAP_FMAC2 soap_accept ( struct soap * soap )

Definition at line 7009 of file stdsoap2.cpp.

 {
   int n = (int)sizeof(soap->peer);
   int err;
 #ifndef WITH_LEAN
   int set = 1;
 #endif
   soap->error = SOAP_OK;
   memset((void*)&soap->peer, 0, sizeof(soap->peer));
   soap->socket = SOAP_INVALID_SOCKET;
   soap->errmode = 0;
   soap_reset_errno;
   soap->errnum = 0;
   soap->keep_alive = 0;
   if (!soap_valid_socket(soap->master))
   {
     soap_set_receiver_error(soap, tcp_error(soap), "no master socket in soap_accept()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #ifndef WITH_LEAN
   if ((soap->omode & SOAP_IO_UDP))
     return soap->socket = soap->master;
 #endif
   for (;;)
   {
     if (soap->accept_timeout)
     {
       for (;;)
       {
         int r;
         r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_ALL, soap->accept_timeout);
         if (r > 0)
           break;
         if (!r)
         {
           soap_set_receiver_error(soap, "Timeout", "accept failed in soap_accept()", SOAP_TCP_ERROR);
           return SOAP_INVALID_SOCKET;
         }
         if (r < 0)
         {
           r = soap->errnum;
           if (r != SOAP_EINTR)
           {
             soap_closesock(soap);
             soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
             return SOAP_INVALID_SOCKET;
           }
         }
       }
     }
     n = (int)sizeof(soap->peer);
     soap->socket = soap->faccept(soap, soap->master, &soap->peer.addr, &n);
     soap->peerlen = (size_t)n;
     if (soap_valid_socket(soap->socket))
     {
 #ifdef WITH_IPV6
       char port[16];
       struct addrinfo *res = NULL;
       struct addrinfo hints;
       memset(&hints, 0, sizeof(struct addrinfo));
       hints.ai_family = PF_UNSPEC;
       hints.ai_socktype = SOCK_STREAM;
       hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
       getnameinfo(&soap->peer.addr, n, soap->host, sizeof(soap->host), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
       soap->ip = 0;
       soap->ip6[0] = 0;
       soap->ip6[1] = 0;
       soap->ip6[2] = 0;
       soap->ip6[3] = 0;
       if (getaddrinfo(soap->host, NULL, &hints, &res) == 0 && res)
       {
         struct sockaddr_storage result;
         memset((void*)&result, 0, sizeof(result));
         (void)soap_memcpy(&result, sizeof(result), res->ai_addr, res->ai_addrlen);
         freeaddrinfo(res);
         if (result.ss_family == AF_INET6)
         {
           struct sockaddr_in6 *addr = (struct sockaddr_in6*)&result;
           struct in6_addr *inaddr = &addr->sin6_addr;
           int i;
           for (i = 0; i < 16; i++)
             soap->ip6[i/4] = (soap->ip6[i/4] << 8) + inaddr->s6_addr[i];
         }
         else if (result.ss_family == AF_INET)
         {
           struct sockaddr_in *addr = (struct sockaddr_in*)&result;
           soap->ip = ntohl(addr->sin_addr.s_addr);
           soap->ip6[2] = 0xFFFF;
           soap->ip6[3] = soap->ip;
         }
       }
       soap->port = soap_strtol(port, NULL, 10);
 #else
       soap->ip = ntohl(soap->peer.in.sin_addr.s_addr);
       soap->ip6[0] = 0;
       soap->ip6[1] = 0;
       soap->ip6[2] = 0xFFFF;
       soap->ip6[3] = soap->ip;
       (SOAP_SNPRINTF(soap->host, sizeof(soap->host), 80), "%u.%u.%u.%u", (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF);
       soap->port = (int)ntohs(soap->peer.in.sin_port); /* does not return port number on some systems */
 #endif
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Accept socket=%d at port=%d from IP='%s'\n", (int)soap->socket, soap->port, soap->host));
 #ifndef WITH_LEAN
       if ((soap->accept_flags & SO_LINGER))
       {
         struct linger linger;
         memset((void*)&linger, 0, sizeof(linger));
         linger.l_onoff = 1;
         linger.l_linger = soap->linger_time;
         if (setsockopt(soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
         {
           soap->errnum = soap_socket_errno;
           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR);
           soap_closesock(soap);
           return SOAP_INVALID_SOCKET;
         }
       }
       if ((soap->accept_flags & ~SO_LINGER) && setsockopt(soap->socket, SOL_SOCKET, soap->accept_flags & ~SO_LINGER, (char*)&set, sizeof(int)))
       {
         soap->errnum = soap_socket_errno;
         soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_accept()", SOAP_TCP_ERROR);
         soap_closesock(soap);
         return SOAP_INVALID_SOCKET;
       }
 #ifndef UNDER_CE
       if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
       {
         soap->errnum = soap_socket_errno;
         soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR);
         soap_closesock(soap);
         return SOAP_INVALID_SOCKET;
       }
       if (soap->sndbuf > 0 && setsockopt(soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&soap->sndbuf, sizeof(int)))
       {
         soap->errnum = soap_socket_errno;
         soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR);
         soap_closesock(soap);
         return SOAP_INVALID_SOCKET;
       }
       if (soap->rcvbuf > 0 && setsockopt(soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&soap->rcvbuf, sizeof(int)))
       {
         soap->errnum = soap_socket_errno;
         soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR);
         soap_closesock(soap);
         return SOAP_INVALID_SOCKET;
       }
 #ifdef TCP_NODELAY
       if (setsockopt(soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
       {
         soap->errnum = soap_socket_errno;
         soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR);
         soap_closesock(soap);
         return SOAP_INVALID_SOCKET;
       }
 #endif
 #endif
 #endif
       soap->keep_alive = -(((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
       if (soap->send_timeout || soap->recv_timeout)
         SOAP_SOCKNONBLOCK(soap->socket)
       else
         SOAP_SOCKBLOCK(soap->socket)
       return soap->socket;
     }
     err = soap_socket_errno;
     if (err != 0 && err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Accept failed from %s\n", soap->host));
       soap->errnum = err;
       soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
       soap_closesock(soap);
       return SOAP_INVALID_SOCKET;
     }
   }
 }

References soap::accept_flags, soap::accept_timeout, soap::addr, DBGLOG, soap::errmode, soap::errnum, soap::error, soap::faccept, soap::host, soap::imode, soap::in, soap::ip, soap::ip6, soap::keep_alive, soap::linger_time, soap::master, memset, NULL, soap::omode, soap::peer, soap::peerlen, soap::port, soap::rcvbuf, soap::recv_timeout, soap::send_timeout, set(), soap::sndbuf, soap_closesock(), SOAP_EAGAIN, SOAP_EINTR, SOAP_EWOULDBLOCK, SOAP_INVALID_SOCKET, SOAP_IO_KEEPALIVE, SOAP_IO_UDP, soap_memcpy, SOAP_OK, soap_reset_errno, soap_set_receiver_error(), SOAP_SNPRINTF, SOAP_SOCKBLOCK, soap_socket_errno, SOAP_SOCKNONBLOCK, soap_strtol, SOAP_TCP_ERROR, SOAP_TCP_SELECT_ALL, soap_valid_socket, soap::socket, tcp_error(), tcp_select(), and TEST().

Referenced by ACSoapThread().

◆ soap_add_att()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_add_att	(	struct soap_dom_element *	elt,
		const struct soap_dom_attribute *	node
	)

◆ soap_add_atts()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_add_atts	(	struct soap_dom_element *	elt,
		const struct soap_dom_attribute *	atts
	)

◆ soap_add_elt()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_add_elt	(	struct soap_dom_element *	elt,
		const struct soap_dom_element *	node
	)

◆ soap_add_elts()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_add_elts	(	struct soap_dom_element *	elt,
		const struct soap_dom_element *	elts
	)

◆ soap_alloc_block()

SOAP_FMAC1 struct soap_blist* SOAP_FMAC2 soap_alloc_block ( struct soap * soap )

Definition at line 2887 of file stdsoap2.cpp.

 {
   struct soap_blist *p;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New block sequence (prev=%p)\n", (void*)soap->blist));
   p = (struct soap_blist*)SOAP_MALLOC(soap, sizeof(struct soap_blist));
   if (!p)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   p->next = soap->blist;
   p->head = NULL;
   p->size = 0;
   p->item = 0;
   soap->blist = p;
   return p;
 }

References soap::blist, DBGLOG, soap::error, soap_blist::head, soap_blist::item, soap_blist::next, NULL, soap_blist::size, SOAP_EOM, SOAP_MALLOC, and TEST().

Referenced by soap_getdime(), soap_gethex(), soap_http_get_body_prefix(), soap_init_send(), soap_peek_element(), soap_QName(), soap_QName2s(), soap_recv_mime_attachment(), soap_string_in(), and soap_wstring_in().

◆ soap_append_lab()

SOAP_FMAC1 int SOAP_FMAC2 soap_append_lab	(	struct soap *	soap,
		const char *	s,
		size_t	n
	)

Definition at line 14396 of file stdsoap2.cpp.

 {
   if (soap->labidx + n < soap->labidx)
     return soap->error = SOAP_EOM;
   if (soap->labidx + n >= soap->lablen)
   {
     char *t = soap->labbuf;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enlarging look-aside buffer to append data, size=%lu\n", (unsigned long)soap->lablen));
     if (soap->lablen == 0)
       soap->lablen = SOAP_LABLEN;
     while (soap->labidx + n >= soap->lablen)
     {
       if (soap->lablen << 1 < soap->lablen)
         return soap->error = SOAP_EOM;
       soap->lablen <<= 1;
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New look-aside buffer size=%lu\n", (unsigned long)soap->lablen));
     if (SOAP_MAXALLOCSIZE > 0 && soap->lablen > SOAP_MAXALLOCSIZE)
       return soap->error = SOAP_EOM;
     soap->labbuf = (char*)SOAP_MALLOC(soap, soap->lablen);
     if (!soap->labbuf)
     {
       if (t)
         SOAP_FREE(soap, t);
       return soap->error = SOAP_EOM;
     }
     if (t)
     {
       (void)soap_memcpy((void*)soap->labbuf, soap->lablen, (const void*)t, soap->labidx);
       SOAP_FREE(soap, t);
     }
   }
   if (s)
   {
     (void)soap_memcpy((void*)(soap->labbuf + soap->labidx), soap->lablen - soap->labidx, (const void*)s, n);
     soap->labidx += n;
   }
   return SOAP_OK;
 }

References DBGLOG, soap::error, soap::labbuf, soap::labidx, soap::lablen, SOAP_EOM, SOAP_FREE, SOAP_LABLEN, SOAP_MALLOC, SOAP_MAXALLOCSIZE, soap_memcpy, SOAP_OK, and TEST().

Referenced by soap_getbase64(), soap_gethex(), soap_peek_element(), soap_QName(), soap_QName2s(), soap_store_lab(), soap_string_in(), and soap_wstring().

◆ soap_array_begin_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_array_begin_out	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	type,
		const char *	offset
	)

Definition at line 13340 of file stdsoap2.cpp.

 {
   if (!type || !*type || soap->version == 0)
     return soap_element_begin_out(soap, tag, id, NULL);
   if (soap_element(soap, tag, id, NULL))
     return soap->error;
   if (soap->version == 1)
   {
     if (offset && soap_attribute(soap, "SOAP-ENC:offset", offset))
       return soap->error;
     if (soap_attribute(soap, "SOAP-ENC:arrayType", type))
       return soap->error;
   }
   else
   {
     const char *s;
     s = strchr(type, '[');
     if (s && (size_t)(s - type) < sizeof(soap->tmpbuf))
     {
       (void)soap_strncpy(soap->tmpbuf, sizeof(soap->tmpbuf), type, s - type);
       if (soap_attribute(soap, "SOAP-ENC:itemType", soap->tmpbuf))
         return soap->error;
       s++;
       if (*s && *s != ']')
       {
         soap_strcpy(soap->tmpbuf, sizeof(soap->tmpbuf), s);
         soap->tmpbuf[strlen(soap->tmpbuf) - 1] = '\0';
         if (soap_attribute(soap, "SOAP-ENC:arraySize", soap->tmpbuf))
           return soap->error;
       }
     }
   }
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_XML_CANONICAL_NA))
     soap_utilize_ns(soap, type, 0);
 #endif
   return soap_element_start_end_out(soap, NULL);
 }

References soap::error, if(), soap::mode, NULL, soap_attribute(), soap_element(), soap_element_begin_out(), soap_element_start_end_out(), soap_strcpy, soap_strncpy, soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_CANONICAL_NA, soap::tmpbuf, and soap::version.

◆ soap_array_pointer_lookup()

SOAP_FMAC1 int SOAP_FMAC2 soap_array_pointer_lookup	(	struct soap *	soap,
		const void *	p,
		const void *	a,
		int	n,
		int	t,
		struct soap_plist **	ppp
	)

Definition at line 9720 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   *ppp = NULL;
   if (!p || !a)
     return 0;
   for (pp = soap->pht[soap_hash_ptr(a)]; pp; pp = pp->next)
   {
     if (pp->type == type && pp->array == a && pp->size == n)
     {
       *ppp = pp;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d id=%d\n", a, type, pp->id));
       return pp->id;
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d: not found\n", a, type));
   return 0;
 }

References mpq::a, soap_plist::array, DBGLOG, soap_plist::id, soap_plist::next, NULL, soap::pht, soap_plist::size, soap_hash_ptr, TEST(), and soap_plist::type.

Referenced by soap_array_reference(), soap_attachment(), soap_attachment_reference(), soap_element_id(), and soap_embed().

◆ soap_array_reference()

SOAP_FMAC1 int SOAP_FMAC2 soap_array_reference	(	struct soap *	soap,
		const void *	p,
		const void *	a,
		int	n,
		int	t
	)

Definition at line 10059 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   if (!p || !a || (!soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH)) || (soap->omode & SOAP_XML_TREE))
     return 1;
   if (soap_array_pointer_lookup(soap, p, a, n, t, &pp))
   {
     if (pp->mark1 == 0)
     {
       pp->mark1 = 2;
       pp->mark2 = 2;
     }
   }
   else if (!soap_pointer_enter(soap, p, a, n, t, &pp))
   {
     return 1;
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array reference %p ptr=%p n=%lu t=%d (%d %d)\n", p, a, (unsigned long)n, t, (int)pp->mark1, (int)pp->mark2));
   return pp->mark1;
 }

References mpq::a, DBGLOG, soap::encodingStyle, soap_plist::mark1, soap_plist::mark2, soap::omode, soap_array_pointer_lookup(), soap_pointer_enter(), SOAP_XML_GRAPH, SOAP_XML_TREE, and TEST().

◆ soap_att()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag
	)

◆ soap_att_add()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_add	(	struct soap_dom_attribute *	att,
		const char *	ns,
		const char *	tag
	)

◆ soap_att_add_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_add_w	(	struct soap_dom_attribute *	att,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_att_bool()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_bool	(	struct soap_dom_attribute *	att,
		LONG64	b
	)

◆ soap_att_copy()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_copy	(	struct soap_dom_attribute *	att,
		const struct soap_dom_attribute *	node
	)

◆ soap_att_double()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_double	(	struct soap_dom_attribute *	att,
		double	x
	)

◆ soap_att_find()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_find	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_att_find_next()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_find_next	(	const struct soap_dom_attribute *	att,
		const char *	ns,
		const char *	patt
	)

◆ soap_att_first()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_first ( struct soap_dom_element * elt )

◆ soap_att_get()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_get	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag
	)

◆ soap_att_get_double()

SOAP_FMAC1 double SOAP_FMAC2 soap_att_get_double ( const struct soap_dom_attribute * att )

◆ soap_att_get_int()

SOAP_FMAC1 int SOAP_FMAC2 soap_att_get_int ( const struct soap_dom_attribute * att )

◆ soap_att_get_long()

SOAP_FMAC1 long SOAP_FMAC2 soap_att_get_long ( const struct soap_dom_attribute * att )

◆ soap_att_get_LONG64()

SOAP_FMAC1 LONG64 SOAP_FMAC2 soap_att_get_LONG64 ( const struct soap_dom_attribute * att )

◆ soap_att_get_ns()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_att_get_ns ( const struct soap_dom_attribute * att )

◆ soap_att_get_tag()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_att_get_tag ( const struct soap_dom_attribute * att )

◆ soap_att_get_text()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_att_get_text ( const struct soap_dom_attribute * att )

◆ soap_att_get_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_get_w	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_att_int()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_int	(	struct soap_dom_attribute *	att,
		LONG64	n
	)

◆ soap_att_is_false()

SOAP_FMAC1 int SOAP_FMAC2 soap_att_is_false ( const struct soap_dom_attribute * att )

◆ soap_att_is_true()

SOAP_FMAC1 int SOAP_FMAC2 soap_att_is_true ( const struct soap_dom_attribute * att )

◆ soap_att_match()

SOAP_FMAC1 int SOAP_FMAC2 soap_att_match	(	const struct soap_dom_attribute *	att,
		const char *	ns,
		const char *	patt
	)

◆ soap_att_match_w()

SOAP_FMAC1 int SOAP_FMAC2 soap_att_match_w	(	const struct soap_dom_attribute *	att,
		const char *	ns,
		const wchar_t *	patt
	)

◆ soap_att_new()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_new	(	struct soap *	soap,
		const char *	ns,
		const char *	tag
	)

◆ soap_att_new_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_new_w	(	struct soap *	soap,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_att_next()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_next ( const struct soap_dom_attribute * att )

◆ soap_att_set()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_set	(	struct soap_dom_attribute *	att,
		const char *	ns,
		const char *	tag
	)

◆ soap_att_set_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_set_w	(	struct soap_dom_attribute *	att,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_att_size()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_att_size	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_att_text()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_text	(	struct soap_dom_attribute *	att,
		const char *	text
	)

◆ soap_att_text_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_text_w	(	struct soap_dom_attribute *	att,
		const wchar_t *	text
	)

◆ soap_att_w()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_att_w	(	struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_attachment()

SOAP_FMAC1 int SOAP_FMAC2 soap_attachment	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const void *	p,
		const void *	a,
		int	n,
		const char *	aid,
		const char *	atype,
		const char *	aoptions,
		const char *	type,
		int	t
	)

Definition at line 10217 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   int i;
   if (!p || !a || (!aid && !atype) || (!soap->encodingStyle && !(soap->omode & (SOAP_ENC_DIME | SOAP_ENC_MIME | SOAP_ENC_MTOM | SOAP_XML_GRAPH))) || (soap->omode & SOAP_XML_TREE))
     return soap_element_id(soap, tag, id, p, a, n, type, t, NULL);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attachment tag='%s' id='%s' (%d) type='%s'\n", tag, aid ? aid : SOAP_STR_EOS, id, atype ? atype : SOAP_STR_EOS));
   i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
   if (!i)
   {
     i = soap_pointer_enter(soap, p, a, n, t, &pp);
     if (!i)
     {
       soap->error = SOAP_EOM;
       return -1;
     }
   }
   if (id <= 0)
     id = i;
   if (!aid)
   {
     (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), strlen(soap->dime_id_format) + 20), soap->dime_id_format, id);
     aid = soap_strdup(soap, soap->tmpbuf);
     if (!aid)
       return -1;
   }
   /* Add MTOM xop:Include element when necessary */
   /* TODO: this code to be obsoleted with new import/xop.h conventions */
   if ((soap->omode & SOAP_ENC_MTOM) && strcmp(tag, "xop:Include"))
   {
     if (soap_element_begin_out(soap, tag, 0, type)
      || soap_element_href(soap, "xop:Include", 0, "xmlns:xop=\"http://www.w3.org/2004/08/xop/include\" href", aid)
      || soap_element_end_out(soap, tag))
       return soap->error;
   }
   else if (soap_element_href(soap, tag, 0, "href", aid))
   {
     return soap->error;
   }
   if ((soap->mode & SOAP_IO_LENGTH))
   {
     if (pp->mark1 != 3)
     {
       struct soap_multipart *content;
       if ((soap->omode & SOAP_ENC_MTOM))
         content = soap_alloc_multipart(soap, &soap->mime.first, &soap->mime.last, (const char*)a, n);
       else
         content = soap_alloc_multipart(soap, &soap->dime.first, &soap->dime.last, (const char*)a, n);
       if (!content)
       {
         soap->error = SOAP_EOM;
         return -1;
       }
       if (!strncmp(aid, "cid:", 4)) /* RFC 2111 */
       {
         if ((soap->omode & SOAP_ENC_MTOM))
         {
           size_t l = strlen(aid) - 1;
           char *s = (char*)soap_malloc(soap, l);
           if (s)
           {
             s[0] = '<';
             (void)soap_strncpy(s + 1, l - 1, aid + 4, l - 3);
             s[l - 2] = '>';
             s[l - 1] = '\0';
             content->id = s;
           }
         }
         else
         {
           content->id = aid + 4;
         }
       }
       else
       {
         content->id = aid;
       }
       content->type = atype;
       content->options = aoptions;
       content->encoding = SOAP_MIME_BINARY;
       pp->mark1 = 3;
     }
   }
   else
   {
     pp->mark2 = 3;
   }
   return -1;
 }

References mpq::a, DBGLOG, soap::dime, soap::dime_id_format, soap_multipart::encoding, soap::encodingStyle, soap::error, soap_dime::first, soap_mime::first, soap_plist::id, soap_multipart::id, mpq::l, soap_dime::last, soap_mime::last, soap_plist::mark1, soap_plist::mark2, soap::mime, soap::mode, NULL, soap::omode, soap_multipart::options, soap_alloc_multipart(), soap_array_pointer_lookup(), soap_element_begin_out(), soap_element_end_out(), soap_element_href(), soap_element_id(), SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_MTOM, SOAP_EOM, SOAP_IO_LENGTH, soap_malloc(), SOAP_MIME_BINARY, soap_pointer_enter(), SOAP_SNPRINTF, SOAP_STR_EOS, soap_strdup(), soap_strncpy, SOAP_XML_GRAPH, SOAP_XML_TREE, TEST(), soap::tmpbuf, and soap_multipart::type.

◆ soap_attachment_forward()

SOAP_FMAC1 int SOAP_FMAC2 soap_attachment_forward	(	struct soap *	soap,
		unsigned char **	ptr,
		int *	size,
		char **	id,
		char **	type,
		char **	options
	)

Definition at line 2742 of file stdsoap2.cpp.

 {
   struct soap_xlist *xp;
   *ptr = NULL;
   *size = 0;
   *id = NULL;
   *type = NULL;
   *options = NULL;
   if (!*soap->href)
     return SOAP_OK;
   *id = soap_strdup(soap, soap->href);
   xp = (struct soap_xlist*)SOAP_MALLOC(soap, sizeof(struct soap_xlist));
   if (!xp)
     return soap->error = SOAP_EOM;
   xp->next = soap->xlist;
   xp->ptr = ptr;
   xp->size = size;
   xp->id = *id;
   xp->type = type;
   xp->options = options;
   soap->xlist = xp;
   return SOAP_OK;
 }

References soap::error, soap::href, soap_xlist::id, soap_xlist::next, NULL, soap_xlist::options, ptr(), soap_xlist::ptr, soap_xlist::size, SOAP_EOM, SOAP_MALLOC, SOAP_OK, soap_strdup(), soap_xlist::type, and soap::xlist.

Referenced by soap_xop_forward().

◆ soap_attachment_reference()

SOAP_FMAC1 int SOAP_FMAC2 soap_attachment_reference	(	struct soap *	soap,
		const void *	p,
		const void *	a,
		int	n,
		int	t,
		const char *	id,
		const char *	type
	)

Definition at line 10087 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   if (!p || !a || (!soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH) && !id && !type) || (soap->omode & SOAP_XML_TREE))
     return 1;
   if (soap_array_pointer_lookup(soap, p, a, n, t, &pp))
   {
     if (pp->mark1 == 0)
     {
       pp->mark1 = 2;
       pp->mark2 = 2;
     }
   }
   else if (!soap_pointer_enter(soap, p, a, n, t, &pp))
   {
     return 1;
   }
   if (id || type)
     soap->mode |= SOAP_ENC_DIME;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attachment reference %p ptr=%p n=%lu t=%d (%d %d)\n", p, a, (unsigned long)n, t, (int)pp->mark1, (int)pp->mark2));
   return pp->mark1;
 }

References mpq::a, DBGLOG, soap::encodingStyle, soap_plist::mark1, soap_plist::mark2, soap::mode, soap::omode, soap_array_pointer_lookup(), SOAP_ENC_DIME, soap_pointer_enter(), SOAP_XML_GRAPH, SOAP_XML_TREE, and TEST().

◆ soap_attr_value()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_attr_value	(	struct soap *	soap,
		const char *	name,
		int	flag,
		int	occurs
	)

Definition at line 14033 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp;
   if (*name == '-')
     return SOAP_STR_EOS;
   for (tp = soap->attributes; tp; tp = tp->next)
   {
     if (tp->visible == 2 && !soap_match_att(soap, tp->name, name))
       break;
   }
   if (tp)
   {
     if (occurs == 4 || (occurs == 2 && (soap->mode & SOAP_XML_STRICT)))
       soap->error = SOAP_PROHIBITED;
     else if (flag >= 4)
       return soap_collapse(soap, tp->value, flag, 1);
     else
       return tp->value;
   }
   else if (occurs == 3 || (occurs == 1 && (soap->mode & SOAP_XML_STRICT)))
   {
     soap->error = SOAP_REQUIRED;
   }
   else
   {
     soap->error = SOAP_OK;
   }
   return NULL;
 }

References soap::attributes, soap::error, soap_attribute::flag, soap::mode, soap_attribute::name, soap_attribute::next, NULL, soap_collapse(), soap_match_att(), SOAP_OK, SOAP_PROHIBITED, SOAP_REQUIRED, SOAP_STR_EOS, SOAP_XML_STRICT, soap_attribute::value, and soap_attribute::visible.

◆ soap_attribute()

SOAP_FMAC1 int SOAP_FMAC2 soap_attribute	(	struct soap *	soap,
		const char *	name,
		const char *	value
	)

Definition at line 13829 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attribute '%s'='%s'\n", name, value));
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom)
   {
     struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
     if (!a)
       return soap->error;
     a->next = soap->dom->atts;
     a->nstr = NULL;
     a->name = soap_strdup(soap, name);
     a->text = soap_strdup(soap, value);
     a->soap = soap;
     soap->dom->atts = a;
     if (!a->name || (value && !a->text))
       return soap->error = SOAP_EOM;
     return SOAP_OK;
   }
 #endif
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL))
   {
     /* push namespace */
     if (!strncmp(name, "xmlns", 5) && ((name[5] == ':') || name[5] == '\0'))
     {
       (void)soap_push_ns(soap, name + 5 + (name[5] == ':'), value, 0, 0);
       if (name[5] == '\0')
         soap_utilize_ns(soap, SOAP_STR_EOS, 0);
       else if (soap->c14ninclude && ((*soap->c14ninclude == '*' || soap_tagsearch(soap->c14ninclude, name + 6))))
         soap_utilize_ns(soap, name, 0);
     }
     else
     {
       soap->level--;
       if (soap_set_attr(soap, name, value, 1))
         return soap->error;
       soap->level++;
     }
   }
   else
 #endif
   {
     if (soap_send_raw(soap, " ", 1)
      || soap_send(soap, name))
       return soap->error;
     if (value)
       if (soap_send_raw(soap, "=\"", 2)
        || soap_string_out(soap, value, 1)
        || soap_send_raw(soap, "\"", 1))
         return soap->error;
   }
   return SOAP_OK;
 }

References mpq::a, soap_dom_element::atts, soap::c14ninclude, DBGLOG, soap::dom, soap::error, soap::level, soap::mode, name, soap_dom_attribute::name, NULL, soap, SOAP_EOM, soap_malloc(), SOAP_OK, soap_push_ns(), soap_send(), soap_send_raw(), soap_set_attr(), SOAP_STR_EOS, soap_strdup(), soap_string_out(), soap_tagsearch(), soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_DOM, and TEST().

Referenced by soap_array_begin_out(), soap_element(), soap_element_href(), soap_element_nil(), soap_element_null(), and soap_element_result().

◆ soap_base642s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_base642s	(	struct soap *	soap,
		const char *	s,
		char *	t,
		size_t	l,
		int *	n
	)

Definition at line 21630 of file stdsoap2.cpp.

 {
   size_t i, j;
   soap_wchar c;
   unsigned long m;
   const char *p;
   if (!s || !*s)
   {
     if (n)
       *n = 0;
     if (soap->error)
       return NULL;
     return SOAP_NON_NULL;
   }
   if (!t)
   {
     l = (strlen(s) + 3) / 4 * 3 + 1;    /* space for raw binary and \0 */
     t = (char*)soap_malloc(soap, l);
   }
   if (!t)
     return NULL;
   p = t;
   if (n)
     *n = 0;
   for (i = 0; ; i += 3, l -= 3)
   {
     m = 0;
     j = 0;
     while (j < 4)
     {
       c = *s++;
       if (c == '=' || !c)
       {
         if (l >= j - 1)
         {
           switch (j)
           {
             case 2:
               *t++ = (char)((m >> 4) & 0xFF);
               i++;
               l--;
               break;
             case 3:
               *t++ = (char)((m >> 10) & 0xFF);
               *t++ = (char)((m >> 2) & 0xFF);
               i += 2;
               l -= 2;
           }
         }
         if (n)
           *n = (int)i;
         if (l)
           *t = '\0';
         return p;
       }
       c -= '+';
       if (c >= 0 && c <= 79)
       {
         int b = soap_base64i[c];
         if (b >= 64)
         {
           soap->error = SOAP_TYPE;
           return NULL;
         }
         m = (m << 6) + b;
         j++;
       }
       else if (!soap_coblank(c + '+'))
       {
         soap->error = SOAP_TYPE;
         return NULL;
       }
     }
     if (l < 3)
     {
       if (n)
         *n = (int)i;
       if (l)
         *t = '\0';
       return p;
     }
     *t++ = (char)((m >> 16) & 0xFF);
     *t++ = (char)((m >> 8) & 0xFF);
     *t++ = (char)(m & 0xFF);
   }
 }

References b, mpq::c, soap::error, mpq::l, NULL, soap_base64i, soap_coblank, soap_malloc(), SOAP_NON_NULL, and SOAP_TYPE.

Referenced by http_parse_header(), and soap_getbase64().

◆ soap_begin()

SOAP_FMAC1 void SOAP_FMAC2 soap_begin ( struct soap * soap )

Definition at line 12402 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Clean up for input/output\n"));
   soap->error = SOAP_OK;
   if (!soap->keep_alive)
   {
     soap->buflen = 0;
     soap->bufidx = 0;
   }
   soap->encoding = 0;
   soap->mode = 0;
   soap->part = SOAP_END;
   soap->peeked = 0;
   soap->ahead = 0;
   soap->level = 0;
   *soap->endpoint = '\0';
   soap->encodingStyle = SOAP_STR_EOS;
   soap_free_temp(soap);
 }

References soap::ahead, soap::bufidx, soap::buflen, DBGLOG, soap::encoding, soap::encodingStyle, soap::endpoint, soap::error, soap::fdebug, soap::keep_alive, soap::level, soap::mode, soap::part, soap::peeked, SOAP_END, soap_free_temp(), SOAP_OK, SOAP_STR_EOS, and TEST().

Referenced by soap_begin_serve().

◆ soap_begin_count()

SOAP_FMAC1 int SOAP_FMAC2 soap_begin_count ( struct soap * soap )

Definition at line 9744 of file stdsoap2.cpp.

 {
   soap_free_ns(soap);
   soap->error = SOAP_OK;
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_ENC_DIME) || (soap->omode & SOAP_ENC_DIME))
   {
     soap->mode = soap->omode | SOAP_IO_LENGTH | SOAP_ENC_DIME;
   }
   else
 #endif
   {
     soap->mode = soap->omode;
     if ((soap->mode & SOAP_IO_UDP))
     {
       soap->mode &= SOAP_IO;
       soap->mode |= SOAP_IO_BUFFER | SOAP_ENC_PLAIN;
     }
     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE
      || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_PLAIN))
 #ifndef WITH_LEANER
       && !soap->fpreparesend
 #endif
       ))
       soap->mode &= ~SOAP_IO_LENGTH;
     else
       soap->mode |= SOAP_IO_LENGTH;
   }
 #ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
   {
     if (!(soap->mode & SOAP_ENC_DIME))
       soap->mode &= ~SOAP_IO_LENGTH;
     if ((soap->mode & SOAP_ENC_PLAIN))
       soap->mode |= SOAP_IO_BUFFER;
     else
       soap->mode |= SOAP_IO_STORE;
   }
 #endif
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
     soap->mode |= SOAP_ENC_MIME;
   else if (!(soap->mode & SOAP_ENC_MIME))
     soap->mode &= ~SOAP_ENC_MTOM;
   if ((soap->mode & SOAP_ENC_MIME))
     soap_select_mime_boundary(soap);
   soap->dime.list = soap->dime.last;    /* keep track of last DIME attachment */
 #endif
   soap->count = 0;
   soap->ns = 0;
   soap->null = 0;
   soap->position = 0;
   soap->mustUnderstand = 0;
   soap->encoding = 0;
   soap->part = SOAP_BEGIN_SEND;
   soap->event = 0;
   soap->evlev = 0;
   soap->idnum = 0;
   soap->body = 1;
   soap->level = 0;
   soap_clr_attr(soap);
   soap_set_local_namespaces(soap);
 #ifndef WITH_LEANER
   soap->dime.size = 0; /* accumulate total size of attachments */
   if (soap->fprepareinitsend && (soap->mode & SOAP_IO) != SOAP_IO_STORE && (soap->error = soap->fprepareinitsend(soap)) != SOAP_OK)
     return soap->error;
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin count phase (socket=%d mode=0x%x count=" SOAP_ULONG_FORMAT ")\n", (int)soap->socket, (unsigned int)soap->mode, soap->count));
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_IO_LENGTH))
     return soap_begin_attachments(soap);
 #endif
   return SOAP_OK;
 }

References soap::body, soap::count, DBGLOG, soap::dime, soap::encoding, endif(), soap::error, soap::event, soap::evlev, soap::fprepareinitsend, soap::fpreparesend, soap::idnum, soap_dime::last, soap::level, soap_dime::list, soap::mode, soap::mustUnderstand, soap::ns, soap::null, soap::omode, soap::part, soap::position, soap_dime::size, soap_begin_attachments(), SOAP_BEGIN_SEND, soap_clr_attr(), SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_MTOM, SOAP_ENC_PLAIN, SOAP_ENC_ZLIB, soap_free_ns(), SOAP_IO, SOAP_IO_BUFFER, SOAP_IO_CHUNK, SOAP_IO_FLUSH, SOAP_IO_LENGTH, SOAP_IO_STORE, SOAP_IO_UDP, SOAP_OK, soap_select_mime_boundary(), soap_set_local_namespaces(), SOAP_ULONG_FORMAT, soap::socket, and TEST().

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_begin_recv()

SOAP_FMAC1 int SOAP_FMAC2 soap_begin_recv ( struct soap * soap )

Definition at line 20447 of file stdsoap2.cpp.

 {
   soap_wchar c;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for input from socket=%d/fd=%d\n", (int)soap->socket, soap->recvfd));
   soap->error = SOAP_OK;
 #ifndef WITH_LEANER
   soap->recverror = SOAP_OK;
 #endif
   soap_free_temp(soap);
   soap_set_local_namespaces(soap);
   soap->version = 0;    /* don't assume we're parsing SOAP content by default */
 #ifndef WITH_NOIDREF
   soap_free_iht(soap);
 #endif
   if ((soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
   {
     soap->imode &= ~SOAP_IO;
     soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_CHUNK;
   }
   soap->imode &= ~(SOAP_ENC_DIME | SOAP_ENC_MIME | SOAP_ENC_ZLIB);
   soap->mode = soap->imode;
   if (!(soap->mode & SOAP_IO_KEEPALIVE))
     soap->keep_alive = 0;
   if (!soap->keep_alive)
     soap->buflen = soap->bufidx = 0;
   soap->null = 0;
   soap->position = 0;
   soap->mustUnderstand = 0;
   soap->shaky = 0;
   soap->ahead = 0;
   soap->peeked = 0;
   soap->level = 0;
   soap->part = SOAP_BEGIN_RECV;
   soap->count = 0;
   soap->length = 0;
   soap->cdata = 0;
   *soap->endpoint = '\0';
   soap->action = NULL;
   soap->header = NULL;
   soap->fault = NULL;
   soap->status = 0;
   soap->fform = NULL;
   soap->body = 1;
 #ifndef WITH_LEANER
   soap->dom = NULL;
   soap->dime.count = 0;
   soap->dime.chunksize = 0;
   soap->dime.buflen = 0;
   soap->dime.list = NULL;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
   soap->mime.list = NULL;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->mime.boundary = NULL;
   soap->mime.start = NULL;
 #endif
 #ifdef WIN32
 #ifndef UNDER_CE
 #ifndef WITH_FASTCGI
   if (!soap_valid_socket(soap->socket) && !soap->is && soap->recvfd >= 0) /* Set win32 stdin or soap->recvfd to BINARY, e.g. to support DIME */
 #ifdef __BORLANDC__
     setmode(soap->recvfd, _O_BINARY);
 #else
     _setmode(soap->recvfd, _O_BINARY);
 #endif
 #endif
 #endif
 #endif
 #ifdef WITH_ZLIB
   soap->zlib_in = SOAP_ZLIB_NONE;
   soap->zlib_out = SOAP_ZLIB_NONE;
   if (!soap->d_stream)
   {
     soap->d_stream = (z_stream*)SOAP_MALLOC(soap, sizeof(z_stream));
     if (!soap->d_stream)
       return soap->error = SOAP_EOM;
     soap->d_stream->zalloc = Z_NULL;
     soap->d_stream->zfree = Z_NULL;
     soap->d_stream->opaque = Z_NULL;
     soap->d_stream->next_in = Z_NULL;
     soap->d_stream->msg = Z_NULL;
   }
   soap->d_stream->avail_in = 0;
   soap->d_stream->next_out = (Byte*)soap->buf;
   soap->d_stream->avail_out = sizeof(soap->buf);
   soap->z_ratio_in = 1.0;
 #endif
 #ifdef WITH_OPENSSL
   if (soap->ssl)
     ERR_clear_error();
 #endif
 #ifndef WITH_LEAN
   soap->start = (ULONG64)time(NULL);
 #endif
 #ifndef WITH_LEANER
   if (soap->fprepareinitrecv && (soap->error = soap->fprepareinitrecv(soap)) != SOAP_OK)
     return soap->error;
 #endif
   c = soap_getchar(soap);
 #ifdef WITH_GZIP
   if (c == 0x1F)
   {
     if (soap_getgziphdr(soap))
       return soap->error;
     if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
       return soap->error = SOAP_ZLIB_ERROR;
     if (soap->z_dict)
     {
       if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
         return soap->error = SOAP_ZLIB_ERROR;
     }
     soap->zlib_state = SOAP_ZLIB_INFLATE;
     soap->mode |= SOAP_ENC_ZLIB;
     soap->zlib_in = SOAP_ZLIB_GZIP;
     soap->z_crc = crc32(0L, NULL, 0);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
     if (!soap->z_buf)
       soap->z_buf = (char*)SOAP_MALLOC(soap, sizeof(soap->buf));
     (void)soap_memcpy((void*)soap->z_buf, sizeof(soap->buf), (const void*)soap->buf, sizeof(soap->buf));
     /* should not chunk over plain transport, so why bother to check? */
     /* if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) */
     /*   soap->z_buflen = soap->bufidx; */
     /* else */
     soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
     soap->d_stream->avail_in = (unsigned int)(soap->buflen - soap->bufidx);
     soap->z_buflen = soap->buflen;
     soap->buflen = soap->bufidx;
     c = ' ';
   }
 #endif
   while (soap_coblank(c))
     c = soap_getchar(soap);
 #ifndef WITH_LEANER
   if (c == '-' && soap_get0(soap) == '-')
   {
     soap->mode |= SOAP_ENC_MIME;
   }
   else if ((c & 0xFFFC) == (SOAP_DIME_VERSION | SOAP_DIME_MB) && (soap_get0(soap) & 0xFFF0) == 0x20)
   {
     soap->mode |= SOAP_ENC_DIME;
   }
   else
 #endif
   {
     /* skip BOM */
     if (c == 0xEF && soap_get0(soap) == 0xBB)
     {
       soap_get1(soap);
       c = soap_get1(soap);
       if (c == 0xBF)
       {
         soap->mode &= ~SOAP_ENC_LATIN;
         c = soap_getchar(soap);
       }
       else
       {
         c = (0x0F << 12) | (0xBB << 6) | (c & 0x3F); /* UTF-8 */
       }
     }
     else if ((c == 0xFE && soap_get0(soap) == 0xFF)  /* UTF-16 BE */
           || (c == 0xFF && soap_get0(soap) == 0xFE)) /* UTF-16 LE */
     {
       return soap->error = SOAP_UTF_ERROR;
     }
     /* skip space */
     while (soap_coblank(c))
       c = soap_getchar(soap);
   }
   if ((int)c == EOF)
     return soap->error = SOAP_CHK_EOF;
   soap_unget(soap, c);
 #ifndef WITH_NOHTTP
   /* if not XML/MIME/DIME/ZLIB, assume HTTP method or status line */
   if (((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) && !(soap->mode & (SOAP_ENC_MIME | SOAP_ENC_DIME | SOAP_ENC_ZLIB | SOAP_ENC_PLAIN)))
   {
     soap_mode m = soap->imode;
     soap->error = soap->fparse(soap);
     soap->mode = soap->imode; /* if imode is changed, effectuate */
     soap->imode = m; /* restore imode */
     if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
     {
       soap->chunkbuflen = soap->buflen;
       soap->buflen = soap->bufidx;
       soap->chunksize = 0;
     }
 #ifdef WITH_ZLIB
     soap->mode &= ~SOAP_ENC_ZLIB;
     if (soap->zlib_in != SOAP_ZLIB_NONE)
     {
 #ifdef WITH_GZIP
       if (soap->zlib_in != SOAP_ZLIB_DEFLATE)
       {
         c = soap_get1(soap);
         if (c == (int)EOF)
           return soap->error = SOAP_EOF;
         if (c == 0x1F)
         {
           if (soap_getgziphdr(soap))
             return soap->error;
           if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
             return soap->error = SOAP_ZLIB_ERROR;
           soap->z_crc = crc32(0L, NULL, 0);
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
         }
         else
         {
           soap_revget1(soap);
           if (inflateInit(soap->d_stream) != Z_OK)
             return soap->error = SOAP_ZLIB_ERROR;
           soap->zlib_in = SOAP_ZLIB_DEFLATE;
         }
       }
       else
 #endif
       if (inflateInit(soap->d_stream) != Z_OK)
         return soap->error = SOAP_ZLIB_ERROR;
       if (soap->z_dict)
       {
         if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
           return soap->error = SOAP_ZLIB_ERROR;
       }
       soap->zlib_state = SOAP_ZLIB_INFLATE;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n"));
       soap->mode |= SOAP_ENC_ZLIB;
       if (!soap->z_buf)
         soap->z_buf = (char*)SOAP_MALLOC(soap, sizeof(soap->buf));
       (void)soap_memcpy((void*)soap->z_buf, sizeof(soap->buf), (const void*)soap->buf, sizeof(soap->buf));
       soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
       soap->d_stream->avail_in = (unsigned int)(soap->buflen - soap->bufidx);
       soap->z_buflen = soap->buflen;
       soap->buflen = soap->bufidx;
     }
 #endif
 #ifndef WITH_LEANER
     if (soap->fpreparerecv && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK && soap->buflen > soap->bufidx)
     {
       int r;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Invoking fpreparerecv\n"));
       r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, soap->buflen - soap->bufidx);
       if (r)
         return soap->error = r;
     }
 #endif
     if (soap->error && soap->error < SOAP_STOP)
     {
       if (soap->status >= 200 && soap->status < 600)
       {
         const char *s = soap_http_get_body(soap, NULL);
         (void)soap_end_recv(soap);
         if (soap->status >= 300)
           soap->keep_alive = 0; /* to force close */
         return soap_set_receiver_error(soap, "HTTP Error", s, soap->status);
       }
       return soap->error;
     }
     if (!soap->body && soap->status >= 200 && soap->status < 600)
       return soap->error = soap->status; /* client side received HTTP status code */
     if (soap->status > SOAP_POST)
     {
       soap->fform = NULL;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Invoking http method handler\n"));
       switch (soap->status)
       {
         case SOAP_GET:
           if (soap_http_skip_body(soap) || soap_end_recv(soap))
             return soap->error;
           soap->error = soap->fget(soap);
           break;
         case SOAP_PUT:
           soap->error = soap->fput(soap);
           break;
         case SOAP_PATCH:
           soap->error = soap->fpatch(soap);
           break;
         case SOAP_DEL:
           if (soap_http_skip_body(soap) || soap_end_recv(soap))
             return soap->error;
           soap->error = soap->fdel(soap);
           break;
         case SOAP_HEAD:
           if (soap_http_skip_body(soap) || soap_end_recv(soap))
             return soap->error;
           soap->error = soap->fhead(soap);
           break;
         case SOAP_OPTIONS:
           if (soap_http_skip_body(soap) || soap_end_recv(soap))
             return soap->error;
           soap->error = soap->fopt(soap);
           break;
         default:
           if (soap_http_skip_body(soap) || soap_end_recv(soap))
             return soap->error;
           return 405;
       }
       if (soap->error == SOAP_OK)
         return soap->error = SOAP_STOP; /* prevents further processing */
       if (soap->error != SOAP_FORM || !soap->fform) /* continue if handler returned SOAP_FORM */
         return soap->error;
       soap->error = SOAP_OK;
     }
     if (soap->fform)
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Invoking http form handler\n"));
       soap->error = soap->fform(soap);
       if (soap->error == SOAP_OK)
         return soap->error = SOAP_STOP; /* prevents further processing */
       if (soap->status != SOAP_POST || soap->error != 404) /* continue with POST if handler returned HTTP not found */
         return soap->error;
       soap->error = SOAP_OK;
     }
     if (!soap->body)
       return soap->error = SOAP_NO_DATA;
   }
 #endif
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_ENC_MIME))
   {
     do /* skip preamble */
     {
       c = soap_getchar(soap);
       if ((int)c == EOF)
         return soap->error = SOAP_CHK_EOF;
     } while (c != '-' || soap_get0(soap) != '-');
     soap_unget(soap, c);
     if (soap_getmimehdr(soap))
       return soap->error;
     if (soap->mime.start)
     {
       do
       {
         if (!soap->mime.last->id)
           break;
         if (!soap_match_cid(soap, soap->mime.start, soap->mime.last->id))
           break;
       } while (soap_recv_mime_attachment(soap, NULL));
     }
     if (soap_http_header_attribute(soap, soap->mime.first->type, "application/dime"))
       soap->mode |= SOAP_ENC_DIME;
   }
   if ((soap->mode & SOAP_ENC_DIME))
   {
     if (soap_getdimehdr(soap))
       return soap->error;
     if ((soap->dime.flags & SOAP_DIME_CF))
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked SOAP in DIME message\n"));
       soap->dime.chunksize = soap->dime.size;
       if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
       {
         soap->dime.buflen = soap->buflen;
         soap->buflen = soap->bufidx + soap->dime.chunksize;
       }
       else
       {
         soap->dime.chunksize -= soap->buflen - soap->bufidx;
       }
     }
     soap->count = soap->buflen - soap->bufidx;
     if (soap->recv_maxlength && soap->count > soap->recv_maxlength)
       return soap->error = SOAP_EOF;
   }
 #endif
   return SOAP_OK;
 }

References soap::action, soap::ahead, soap::body, soap_mime::boundary, soap::buf, soap::bufidx, soap_dime::buflen, soap::buflen, mpq::c, soap::cdata, soap::chunkbuflen, soap_dime::chunksize, soap::chunksize, soap_dime::count, soap::count, crc32(), soap::d_stream, DBGLOG, soap::dime, soap::dom, endif(), soap::endpoint, soap::error, soap::fault, soap::fdel, soap::fform, soap::fget, soap::fhead, soap_dime::first, soap_mime::first, soap_dime::flags, soap::fopt, soap::fparse, soap::fpatch, soap::fprepareinitrecv, soap::fpreparerecv, soap::fput, soap::header, soap_multipart::id, if(), soap::imode, inflateInit, inflateInit2, inflateSetDictionary(), soap::is, soap::keep_alive, soap_dime::last, soap_mime::last, soap::length, soap::level, soap_dime::list, soap_mime::list, MAX_WBITS, soap::mime, soap::mode, soap::mustUnderstand, soap::null, NULL, soap::omode, soap::part, soap::peeked, soap::position, soap::recv_maxlength, soap::recverror, soap::recvfd, soap::shaky, soap_dime::size, SOAP_BEGIN_RECV, SOAP_CHK_EOF, soap_coblank, SOAP_DEL, SOAP_DIME_CF, SOAP_DIME_MB, SOAP_DIME_VERSION, SOAP_ENC_DIME, SOAP_ENC_LATIN, SOAP_ENC_MIME, SOAP_ENC_PLAIN, SOAP_ENC_ZLIB, soap_end_recv(), SOAP_EOF, SOAP_EOM, SOAP_FORM, soap_free_iht(), soap_free_temp(), SOAP_GET, soap_get0, soap_get1, soap_getchar(), soap_getdimehdr(), soap_getmimehdr(), SOAP_HEAD, soap_http_get_body(), soap_http_header_attribute(), soap_http_skip_body(), SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_KEEPALIVE, SOAP_MALLOC, soap_match_cid(), soap_memcpy, SOAP_NO_DATA, SOAP_OK, SOAP_OPTIONS, SOAP_PATCH, SOAP_POST, SOAP_PUT, soap_recv_mime_attachment(), soap_revget1, soap_set_local_namespaces(), soap_set_receiver_error(), SOAP_STOP, soap_unget, SOAP_UTF_ERROR, soap_valid_socket, SOAP_ZLIB_DEFLATE, SOAP_ZLIB_ERROR, SOAP_ZLIB_GZIP, SOAP_ZLIB_INFLATE, SOAP_ZLIB_NONE, soap::socket, soap::ssl, soap_mime::start, soap::start, soap::status, TEST(), soap_multipart::type, ULONG64, soap::version, soap::z_buf, soap::z_buflen, soap::z_crc, soap::z_dict, soap::z_dict_len, Z_NULL, Z_OK, soap::z_ratio_in, soap::zlib_in, soap::zlib_out, and soap::zlib_state.

Referenced by soap_begin_serve(), soap_read__QName(), soap_read_byte(), soap_read_int(), soap_read_ns1__executeCommand(), soap_read_ns1__executeCommandResponse(), soap_read_SOAP_ENV__Code(), soap_read_SOAP_ENV__Detail(), soap_read_SOAP_ENV__Fault(), soap_read_SOAP_ENV__Header(), soap_read_SOAP_ENV__Reason(), soap_read_string(), and soap_recv_empty_response().

◆ soap_begin_send()

SOAP_FMAC1 int SOAP_FMAC2 soap_begin_send ( struct soap * soap )

Definition at line 9996 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEANER
   if (soap_init_send(soap))
     return soap->error;
   return soap_begin_attachments(soap);
 #else
   return soap_init_send(soap);
 #endif
 }

References soap::error, soap_begin_attachments(), and soap_init_send().

Referenced by soap_write__QName(), soap_write_byte(), soap_write_int(), soap_write_ns1__executeCommand(), soap_write_ns1__executeCommandResponse(), soap_write_SOAP_ENV__Code(), soap_write_SOAP_ENV__Detail(), soap_write_SOAP_ENV__Fault(), soap_write_SOAP_ENV__Header(), soap_write_SOAP_ENV__Reason(), and soap_write_string().

◆ soap_begin_serve()

SOAP_FMAC1 int SOAP_FMAC2 soap_begin_serve ( struct soap * soap )

Definition at line 20414 of file stdsoap2.cpp.

 {
 #ifdef WITH_FASTCGI
   if (FCGI_Accept() < 0)
   {
     soap->error = SOAP_EOF;
     return soap_send_fault(soap);
   }
 #endif
   soap_begin(soap);
   if (soap_begin_recv(soap)
    || soap_envelope_begin_in(soap)
    || soap_recv_header(soap)
    || soap_body_begin_in(soap))
   {
     if (soap->error < SOAP_STOP)
     {
 #ifdef WITH_FASTCGI
       (void)soap_send_fault(soap);
 #else
       return soap_send_fault(soap);
 #endif
     }
     return soap_closesock(soap);
   }
   return SOAP_OK;
 }

References soap::error, soap_begin(), soap_begin_recv(), soap_body_begin_in(), soap_closesock(), soap_envelope_begin_in(), SOAP_EOF, SOAP_OK, soap_recv_header(), soap_send_fault(), and SOAP_STOP.

Referenced by soap_serve().

◆ soap_begin_shaky()

SOAP_FMAC1 short SOAP_FMAC2 soap_begin_shaky ( struct soap * soap )

Definition at line 10862 of file stdsoap2.cpp.

 {
   short f = soap->shaky;
   soap->shaky = 1;
   return f;
 }

References f(), and soap::shaky.

◆ soap_binary_search_string()

SOAP_FMAC1 int SOAP_FMAC2 soap_binary_search_string	(	const char **	a,
		int	n,
		const char *	s
	)

Definition at line 1873 of file stdsoap2.cpp.

 {
   int min = 0, max = n-1;
   while (min <= max)
   {
     int mid = (min+max)/2;
     int r = strcmp(s, a[mid]);
     if (r < 0)
       max = mid - 1;
     else if (r > 0)
       min = mid + 1;
     else
       return mid;
   }
   return -1;
 }

References mpq::a, max, and min.

◆ soap_bind()

SOAP_FMAC1 SOAP_SOCKET SOAP_FMAC2 soap_bind	(	struct soap *	soap,
		const char *	host,
		int	port,
		int	backlog
	)

Definition at line 6719 of file stdsoap2.cpp.

 {
 #if defined(WITH_IPV6)
   struct addrinfo *addrinfo = NULL;
   struct addrinfo hints;
   struct addrinfo res;
   int err;
   int set = 1;
   int unset = 0;
 #elif !defined(WITH_LEAN)
   int set = 1;
 #endif
   if (soap_valid_socket(soap->master))
   {
     soap->fclosesocket(soap, soap->master);
     soap->master = SOAP_INVALID_SOCKET;
   }
   soap->socket = SOAP_INVALID_SOCKET;
   soap->errnum = 0;
   soap->errmode = 1;
   if (tcp_init(soap))
   {
     soap_set_receiver_error(soap, tcp_error(soap), "TCP init failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #ifdef WITH_IPV6
   memset((void*)&hints, 0, sizeof(hints));
   hints.ai_family = soap->bind_inet6 ? AF_INET6 : PF_UNSPEC;
 #ifndef WITH_LEAN
   if ((soap->omode & SOAP_IO_UDP))
     hints.ai_socktype = SOCK_DGRAM;
   else
 #endif
     hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags = AI_PASSIVE;
   soap->errmode = 2;
   err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
   if (err || !addrinfo)
   {
     soap_set_receiver_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR);
     if (addrinfo)
       freeaddrinfo(addrinfo);
     return SOAP_INVALID_SOCKET;
   }
   res = *addrinfo;
   if (soap_memcpy((void*)&soap->peer.storage, sizeof(soap->peer.storage), (const void*)addrinfo->ai_addr, addrinfo->ai_addrlen))
   {
     freeaddrinfo(addrinfo);
     soap->error = SOAP_EOM;
     return SOAP_INVALID_SOCKET;
   }
   soap->peerlen = addrinfo->ai_addrlen;
   res.ai_addr = &soap->peer.addr;
   res.ai_addrlen = soap->peerlen;
   freeaddrinfo(addrinfo);
   soap->master = (int)socket(res.ai_family, res.ai_socktype, res.ai_protocol);
 #else
 #ifndef WITH_LEAN
   if ((soap->omode & SOAP_IO_UDP))
     soap->master = (int)socket(AF_INET, SOCK_DGRAM, 0);
   else
 #endif
     soap->master = (int)socket(AF_INET, SOCK_STREAM, 0);
 #endif
   soap->errmode = 0;
   if (!soap_valid_socket(soap->master))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "socket failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
   soap->port = port;
 #ifndef WITH_LEAN
   if ((soap->omode & SOAP_IO_UDP))
     soap->socket = soap->master;
 #endif
 #ifdef WITH_SOCKET_CLOSE_ON_EXIT
 #ifdef WIN32
 #ifndef UNDER_CE
   SetHandleInformation((HANDLE)soap->master, HANDLE_FLAG_INHERIT, 0);
 #endif
 #else
   fcntl(soap->master, F_SETFD, 1);
 #endif
 #endif
 #ifndef WITH_LEAN
   if (soap->bind_flags && setsockopt(soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #ifndef UNDER_CE
   if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && (!((soap->imode | soap->omode) & SOAP_IO_UDP)) && setsockopt(soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
   if (soap->sndbuf > 0 && setsockopt(soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&soap->sndbuf, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
   if (soap->rcvbuf > 0 && setsockopt(soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&soap->rcvbuf, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #ifdef TCP_NODELAY
   if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #endif
 #ifdef TCP_FASTOPEN
   if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->master, IPPROTO_TCP, TCP_FASTOPEN, (char*)&set, sizeof(int)))
   {
     /* silently ignore */
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "setsockopt TCP_FASTOPEN failed in soap_bind()\n"));
   }
 #endif
 #endif
 #endif
 #ifdef WITH_IPV6
   if (res.ai_family == AF_INET6 && setsockopt(soap->master, IPPROTO_IPV6, IPV6_V6ONLY, soap->bind_v6only ? (char*)&set : (char*)&unset, sizeof(int)))
   {
     soap->errnum = soap_socket_errno;
     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt IPV6_V6ONLY failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
   soap->errmode = 0;
   if (bind(soap->master, res.ai_addr, (int)res.ai_addrlen))
   {
     soap->errnum = soap_socket_errno;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host, bind failed\n"));
     soap_closesock(soap);
     soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #else
   soap->peerlen = sizeof(soap->peer.in);
   memset((void*)&soap->peer.in, 0, sizeof(soap->peer.in));
   soap->peer.in.sin_family = AF_INET;
   soap->errmode = 2;
   if (host)
   {
     if (soap->fresolve(soap, host, &soap->peer.in.sin_addr))
     {
       soap_set_receiver_error(soap, tcp_error(soap), "get host by name failed in soap_bind()", SOAP_TCP_ERROR);
       return SOAP_INVALID_SOCKET;
     }
   }
   else
     soap->peer.in.sin_addr.s_addr = htonl(INADDR_ANY);
   soap->peer.in.sin_port = htons((short)port);
   soap->errmode = 0;
   if (bind(soap->master, &soap->peer.addr, (int)soap->peerlen))
   {
     soap->errnum = soap_socket_errno;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host, bind failed\n"));
     soap_closesock(soap);
     soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
 #endif
   if (!(soap->omode & SOAP_IO_UDP) && listen(soap->master, backlog))
   {
     soap->errnum = soap_socket_errno;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host, listen failed\n"));
     soap_closesock(soap);
     soap_set_receiver_error(soap, tcp_error(soap), "listen failed in soap_bind()", SOAP_TCP_ERROR);
     return SOAP_INVALID_SOCKET;
   }
   return soap->master;
 }

References soap::addr, soap::bind_flags, soap::bind_inet6, soap::bind_v6only, DBGLOG, soap::errmode, soap::errnum, soap::error, soap::fclosesocket, soap::fresolve, HANDLE, soap::imode, soap::in, soap::master, memset, NULL, soap::omode, soap::peer, soap::peerlen, soap::port, soap::rcvbuf, set(), soap::sndbuf, soap_closesock(), SOAP_EOM, SOAP_GAI_STRERROR, soap_int2s(), SOAP_INVALID_SOCKET, SOAP_IO_KEEPALIVE, SOAP_IO_UDP, soap_memcpy, soap_set_receiver_error(), soap_socket_errno, SOAP_TCP_ERROR, soap_valid_socket, soap::socket, soap::storage, tcp_error(), tcp_init(), and TEST().

Referenced by ACSoapThread().

◆ soap_block_size()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_block_size	(	struct soap *	soap,
		struct soap_blist *	b
	)

Definition at line 3283 of file stdsoap2.cpp.

 {
   if (!b)
     b = soap->blist;
   return b->head->size;
 }

References b, and soap::blist.

Referenced by soap_end_send_flush(), and soap_save_block().

◆ soap_body_begin_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_body_begin_in ( struct soap * soap )

Definition at line 21093 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   soap->part = SOAP_IN_BODY;
   if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL))
     return soap->error;
   if (!soap->body)
     soap->part = SOAP_NO_BODY;
   return SOAP_OK;
 }

References soap::body, soap::error, NULL, soap::part, soap_element_begin_in(), SOAP_IN_BODY, SOAP_NO_BODY, SOAP_OK, and soap::version.

Referenced by soap_begin_serve().

◆ soap_body_begin_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_body_begin_out ( struct soap * soap )

Definition at line 21059 of file stdsoap2.cpp.

 {
   if (soap->version == 1)
     soap->encoding = 1;
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_SEC_WSUID) && soap_set_attr(soap, "wsu:Id", "Body", 1))
     return soap->error;
 #endif
   if (soap->version == 0)
     return SOAP_OK;
   soap->part = SOAP_IN_BODY;
   return soap_element_begin_out(soap, "SOAP-ENV:Body", 0, NULL);
 }

References soap::encoding, soap::error, soap::mode, NULL, soap::part, soap_element_begin_out(), SOAP_IN_BODY, SOAP_OK, SOAP_SEC_WSUID, soap_set_attr(), and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_body_end_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_body_end_in ( struct soap * soap )

Definition at line 21110 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   if (soap->part == SOAP_NO_BODY)
     return soap->error = SOAP_OK;
   soap->part = SOAP_END_BODY;
   return soap_element_end_in(soap, "SOAP-ENV:Body");
 }

References soap::error, soap::part, soap_element_end_in(), SOAP_END_BODY, SOAP_NO_BODY, SOAP_OK, and soap::version.

Referenced by soap_recv_fault(), and soap_serve_ns1__executeCommand().

◆ soap_body_end_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_body_end_out ( struct soap * soap )

Definition at line 21078 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   if (soap_element_end_out(soap, "SOAP-ENV:Body"))
     return soap->error;
   soap->part = SOAP_END_BODY;
   return SOAP_OK;
 }

References soap::error, soap::part, soap_element_end_out(), SOAP_END_BODY, SOAP_OK, and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_byte2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_byte2s	(	struct soap *	soap,
		char	n
	)

Definition at line 16389 of file stdsoap2.cpp.

 {
   return soap_long2s(soap, (long)n);
 }

References soap_long2s().

◆ soap_check_and_mark()

SOAP_FMAC1 int SOAP_FMAC2 soap_check_and_mark	(	struct soap *	soap,
		const void *	p,
		int	t,
		char **	mark
	)

Definition at line 13693 of file stdsoap2.cpp.

 {
   if (mark)
   {
     struct soap_plist *pp;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Check %p and mark %p\n", p, (void*)mark));
     if (!soap_pointer_lookup(soap, p, t, &pp))
       if (!soap_pointer_enter(soap, p, NULL, 0, t, &pp))
         return -1;
     if ((soap->mode & SOAP_IO_LENGTH))
     {
       if (pp->mark1 > 0)
         return -1;
       pp->mark1 = 1;
       *mark = &pp->mark1;
     }
     else
     {
       if (pp->mark2 > 0)
         return -1;
       pp->mark2 = 1;
       *mark = &pp->mark2;
     }
   }
   return 0;
 }

References DBGLOG, soap_plist::mark1, soap_plist::mark2, soap::mode, NULL, SOAP_IO_LENGTH, soap_pointer_enter(), soap_pointer_lookup(), and TEST().

Referenced by soap_element_id().

◆ soap_check_mime_attachments()

SOAP_FMAC1 int SOAP_FMAC2 soap_check_mime_attachments ( struct soap * soap )

Definition at line 19686 of file stdsoap2.cpp.

 {
   if ((soap->mode & SOAP_MIME_POSTCHECK))
     return soap_recv_mime_attachment(soap, NULL) != NULL;
   return 0;
 }

References soap::mode, NULL, SOAP_MIME_POSTCHECK, and soap_recv_mime_attachment().

◆ soap_check_result()

SOAP_FMAC1 void SOAP_FMAC2 soap_check_result	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13814 of file stdsoap2.cpp.

 {
   (void)tag;
   if (soap->version == 2 && soap->encodingStyle)
   {
     soap_instring(soap, ":result", NULL, NULL, 0, 2, -1, -1, NULL);
     /* just ignore content for compliance reasons, but should compare tag to element's QName value? */
   }
 }

References soap::encodingStyle, NULL, soap_instring(), and soap::version.

◆ soap_cleanup()

SOAP_FMAC1 void SOAP_FMAC2 soap_cleanup ( struct soap * soap )

Definition at line 7263 of file stdsoap2.cpp.

 {
   soap_done(soap);
 #ifdef WIN32
   if (!tcp_done)
     return;
   tcp_done = 0;
   WSACleanup();
 #endif
 }

References soap_done().

◆ soap_close_logfiles()

SOAP_FMAC1 void SOAP_FMAC2 soap_close_logfiles ( struct soap * )

Referenced by soap_end().

◆ soap_closesock()

SOAP_FMAC1 int SOAP_FMAC2 soap_closesock ( struct soap * soap )

Definition at line 7191 of file stdsoap2.cpp.

 {
   int status = soap->error;
   int err = SOAP_OK;
   soap->part = SOAP_END;
 #ifndef WITH_LEANER
   if (status && status < 200) /* attachment state is not to be trusted */
   {
     soap->mime.first = NULL;
     soap->mime.last = NULL;
     soap->dime.first = NULL;
     soap->dime.last = NULL;
   }
 #endif
   if (soap->fdisconnect)
     err = soap->fdisconnect(soap);
   if (err || status == SOAP_EOF || status == SOAP_TCP_ERROR || status == SOAP_SSL_ERROR || !soap->keep_alive)
   {
     soap->keep_alive = 0;
     if (soap->fclose && (soap->error = soap->fclose(soap)) != SOAP_OK)
       return soap->error;
     if (err)
       return soap->error = err;
   }
 #ifdef WITH_ZLIB
   if (!(soap->mode & SOAP_MIME_POSTCHECK))
   {
     if (soap->zlib_state == SOAP_ZLIB_DEFLATE)
       deflateEnd(soap->d_stream);
     else if (soap->zlib_state == SOAP_ZLIB_INFLATE)
       inflateEnd(soap->d_stream);
     soap->zlib_state = SOAP_ZLIB_NONE;
   }
 #endif
   return soap->error = status;
 }

References soap::d_stream, deflateEnd(), soap::dime, soap::error, soap::fclose, soap::fdisconnect, soap_dime::first, soap_mime::first, inflateEnd(), soap::keep_alive, soap_dime::last, soap_mime::last, soap::mime, soap::mode, NULL, soap::part, SOAP_END, SOAP_EOF, SOAP_MIME_POSTCHECK, SOAP_OK, SOAP_SSL_ERROR, SOAP_TCP_ERROR, SOAP_ZLIB_DEFLATE, SOAP_ZLIB_INFLATE, SOAP_ZLIB_NONE, and soap::zlib_state.

Referenced by soap_accept(), soap_begin_serve(), soap_bind(), soap_DELETE(), soap_done(), soap_end(), soap_GET__QName(), soap_GET_byte(), soap_GET_int(), soap_GET_ns1__executeCommand(), soap_GET_ns1__executeCommandResponse(), soap_GET_SOAP_ENV__Code(), soap_GET_SOAP_ENV__Detail(), soap_GET_SOAP_ENV__Fault(), soap_GET_SOAP_ENV__Header(), soap_GET_SOAP_ENV__Reason(), soap_GET_string(), soap_PATCH__QName(), soap_PATCH_byte(), soap_PATCH_int(), soap_PATCH_ns1__executeCommand(), soap_PATCH_ns1__executeCommandResponse(), soap_PATCH_SOAP_ENV__Code(), soap_PATCH_SOAP_ENV__Detail(), soap_PATCH_SOAP_ENV__Fault(), soap_PATCH_SOAP_ENV__Header(), soap_PATCH_SOAP_ENV__Reason(), soap_PATCH_string(), soap_POST_recv__QName(), soap_POST_recv_byte(), soap_POST_recv_int(), soap_POST_recv_ns1__executeCommand(), soap_POST_recv_ns1__executeCommandResponse(), soap_POST_recv_SOAP_ENV__Code(), soap_POST_recv_SOAP_ENV__Detail(), soap_POST_recv_SOAP_ENV__Fault(), soap_POST_recv_SOAP_ENV__Header(), soap_POST_recv_SOAP_ENV__Reason(), soap_POST_recv_string(), soap_POST_send__QName(), soap_POST_send_byte(), soap_POST_send_int(), soap_POST_send_ns1__executeCommand(), soap_POST_send_ns1__executeCommandResponse(), soap_POST_send_SOAP_ENV__Code(), soap_POST_send_SOAP_ENV__Detail(), soap_POST_send_SOAP_ENV__Fault(), soap_POST_send_SOAP_ENV__Header(), soap_POST_send_SOAP_ENV__Reason(), soap_POST_send_string(), soap_PUT__QName(), soap_PUT_byte(), soap_PUT_int(), soap_PUT_ns1__executeCommand(), soap_PUT_ns1__executeCommandResponse(), soap_PUT_SOAP_ENV__Code(), soap_PUT_SOAP_ENV__Detail(), soap_PUT_SOAP_ENV__Fault(), soap_PUT_SOAP_ENV__Header(), soap_PUT_SOAP_ENV__Reason(), soap_PUT_string(), soap_recv_empty_response(), soap_recv_fault(), soap_recv_mime_attachment(), soap_send_empty_response(), soap_send_fault(), soap_serve_ns1__executeCommand(), and soap_try_connect_command().

◆ soap_clr_attr()

SOAP_FMAC1 void SOAP_FMAC2 soap_clr_attr ( struct soap * soap )

Definition at line 14212 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp;
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL))
   {
     while (soap->attributes)
     {
       tp = soap->attributes->next;
       if (soap->attributes->value)
         SOAP_FREE(soap, soap->attributes->value);
       SOAP_FREE(soap, soap->attributes);
       soap->attributes = tp;
     }
   }
   else
 #endif
   {
     for (tp = soap->attributes; tp; tp = tp->next)
       tp->visible = 0;
   }
 }

References soap::attributes, soap::mode, soap_attribute::next, SOAP_FREE, SOAP_XML_CANONICAL, soap_attribute::value, and soap_attribute::visible.

Referenced by soap_begin_count(), and soap_init_send().

◆ soap_clr_dime()

SOAP_FMAC1 void SOAP_FMAC2 soap_clr_dime ( struct soap * soap )

Definition at line 20109 of file stdsoap2.cpp.

 {
   soap->omode &= ~SOAP_ENC_DIME;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
 }

References soap::dime, soap_dime::first, soap_dime::last, NULL, soap::omode, and SOAP_ENC_DIME.

◆ soap_clr_mime()

SOAP_FMAC1 void SOAP_FMAC2 soap_clr_mime ( struct soap * soap )

Definition at line 20123 of file stdsoap2.cpp.

 {
   soap->omode &= ~SOAP_ENC_MIME;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->mime.boundary = NULL;
   soap->mime.start = NULL;
 }

References soap_mime::boundary, soap_mime::first, soap_mime::last, soap::mime, NULL, soap::omode, SOAP_ENC_MIME, and soap_mime::start.

Referenced by soap_dealloc().

◆ soap_code()

SOAP_FMAC1 const struct soap_code_map* SOAP_FMAC2 soap_code	(	const struct soap_code_map *	code_map,
		const char *	str
	)

Definition at line 1760 of file stdsoap2.cpp.

 {
   if (code_map && str)
   {
     while (code_map->string)
     {
       if (!strcmp(str, code_map->string)) /* case sensitive */
         return code_map;
       code_map++;
     }
   }
   return NULL;
 }

References NULL, and soap_code_map::string.

◆ soap_code_bits()

SOAP_FMAC1 LONG64 SOAP_FMAC2 soap_code_bits	(	const struct soap_code_map *	code_map,
		const char *	str
	)

Definition at line 1812 of file stdsoap2.cpp.

 {
   LONG64 bits = 0;
   if (code_map)
   {
     while (str && *str)
     {
       const struct soap_code_map *p;
       for (p = code_map; p->string; p++)
       {
         size_t n = strlen(p->string);
         if (!strncmp(p->string, str, n) && soap_coblank((soap_wchar)str[n]))
         {
           bits |= p->code;
           str += n;
           while (*str > 0 && *str <= 32)
             str++;
           break;
         }
       }
       if (!p->string)
         return 0;
     }
   }
   return bits;
 }

References G3D::bits(), soap_code_map::code, LONG64, soap_coblank, and soap_code_map::string.

◆ soap_code_int()

SOAP_FMAC1 LONG64 SOAP_FMAC2 soap_code_int	(	const struct soap_code_map *	code_map,
		const char *	str,
		LONG64	other
	)

Definition at line 1779 of file stdsoap2.cpp.

 {
   if (code_map)
   {
     while (code_map->string)
     {
       if (!soap_tag_cmp(str, code_map->string)) /* case insensitive */
         return code_map->code;
       code_map++;
     }
   }
   return other;
 }

References soap_code_map::code, soap_tag_cmp(), and soap_code_map::string.

Referenced by soap_char(), and soap_getmimehdr().

◆ soap_code_list()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_code_list	(	struct soap *	soap,
		const struct soap_code_map *	code_map,
		long	code
	)

Definition at line 1844 of file stdsoap2.cpp.

 {
   char *t = soap->tmpbuf;
   if (code_map)
   {
     while (code_map->string)
     {
       if ((code_map->code & code))
       {
         const char *s = code_map->string;
         if (t != soap->tmpbuf)
           *t++ = ' ';
         while (*s && t < soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
           *t++ = *s++;
         if (t == soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
           break;
       }
       code_map++;
     }
   }
   *t = '\0';
   return soap->tmpbuf;
 }

References soap_code_map::code, soap_code_map::string, and soap::tmpbuf.

◆ soap_code_str()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_code_str	(	const struct soap_code_map *	code_map,
		long	code
	)

Definition at line 1798 of file stdsoap2.cpp.

 {
   if (!code_map)
     return NULL;
   while (code_map->code != code && code_map->string)
     code_map++;
   return code_map->string;
 }

References soap_code_map::code, NULL, and soap_code_map::string.

Referenced by http_error(), soap_count_attachments(), soap_putmimehdr(), and tcp_error().

◆ soap_connect()

SOAP_FMAC1 int SOAP_FMAC2 soap_connect	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action
	)

Definition at line 21329 of file stdsoap2.cpp.

 {
   return soap_connect_command(soap, SOAP_POST, endpoint, action);
 }

References soap_connect_command(), and SOAP_POST.

◆ soap_connect_command()

SOAP_FMAC1 int SOAP_FMAC2 soap_connect_command	(	struct soap *	soap,
		int	http_command,
		const char *	endpoints,
		const char *	action
	)

Definition at line 21339 of file stdsoap2.cpp.

 {
   if (endpoints)
   {
     int retry = soap->connect_retry;
     unsigned int backoff = 1;
     for (;;)
     {
       struct timeval tv;
       const char *s;
       s = strchr(endpoints, ' ');
       if (s)
       {
         size_t l = strlen(endpoints);
         char *endpoint = NULL;
         if (SOAP_MAXALLOCSIZE == 0 || l <= SOAP_MAXALLOCSIZE)
           endpoint = (char*)SOAP_MALLOC(soap, l + 1);
         if (!endpoint)
           return soap->error = SOAP_EOM;
         for (;;)
         {
           (void)soap_strncpy(endpoint, l + 1, endpoints, s - endpoints);
           endpoint[s - endpoints] = '\0';
           if (soap_try_connect_command(soap, http_command, endpoint, action) != SOAP_TCP_ERROR)
             break;
           while (*s == ' ')
             s++;
           if (!*s)
             break;
           soap->error = SOAP_OK;
           endpoints = s;
           s = strchr(endpoints, ' ');
           if (!s)
             s = endpoints + strlen(endpoints);
         }
         SOAP_FREE(soap, endpoint);
       }
       else
       {
         soap_try_connect_command(soap, http_command, endpoints, action);
       }
       if (soap->error != SOAP_TCP_ERROR || retry <= 0)
         break;
       soap->error = SOAP_OK;
       tv.tv_sec = backoff;
       tv.tv_usec = 0;
       select(0, NULL, NULL, NULL, &tv);
       if (backoff < 32)
         backoff *= 2;
       --retry;
     }
   }
   return soap->error;
 }

References soap::connect_retry, soap::error, mpq::l, NULL, SOAP_EOM, SOAP_FREE, SOAP_MALLOC, SOAP_MAXALLOCSIZE, SOAP_OK, soap_strncpy, SOAP_TCP_ERROR, and soap_try_connect_command().

Referenced by soap_connect(), soap_DELETE(), soap_GET(), soap_PATCH(), soap_POST(), and soap_PUT().

◆ soap_copy()

SOAP_FMAC1 struct soap* SOAP_FMAC2 soap_copy ( const struct soap * soap )

Definition at line 11703 of file stdsoap2.cpp.

 {
   struct soap *copy = soap_versioning(soap_new)(SOAP_IO_DEFAULT, SOAP_IO_DEFAULT);
   soap_set_test_logfile(copy, NULL);
   soap_set_sent_logfile(copy, NULL);
   soap_set_recv_logfile(copy, NULL);
   soap_done(copy);
   if (soap_copy_context(copy, soap) != NULL)
     return copy;
   soap_free(copy);
   return NULL;
 }

References detail::copy(), NULL, soap_copy_context(), soap_done(), soap_free(), SOAP_IO_DEFAULT, soap_new(), soap_set_recv_logfile(), soap_set_sent_logfile(), soap_set_test_logfile(), and soap_versioning.

Referenced by ACSoapThread().

◆ soap_copy_context()

SOAP_FMAC1 struct soap* SOAP_FMAC2 soap_copy_context	(	struct soap *	copy,
		const struct soap *	soap
	)

Definition at line 11721 of file stdsoap2.cpp.

 {
   if (copy == soap)
     return copy;
   if (soap_check_state(soap))
     return NULL;
   if (copy)
   {
     struct soap_plugin *p = NULL;
     (void)soap_memcpy((void*)copy, sizeof(struct soap), (const void*)soap, sizeof(struct soap));
     copy->state = SOAP_COPY;
 #ifdef SOAP_MEM_DEBUG
     soap_init_mht(copy);
 #endif
 #ifdef SOAP_DEBUG
     soap_init_logs(copy);
     soap_set_test_logfile(copy, soap->logfile[SOAP_INDEX_TEST]);
     soap_set_sent_logfile(copy, soap->logfile[SOAP_INDEX_SENT]);
     soap_set_recv_logfile(copy, soap->logfile[SOAP_INDEX_RECV]);
 #endif
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying context\n"));
     copy->error = SOAP_OK;
     copy->bearer = NULL;
     copy->userid = NULL;
     copy->passwd = NULL;
 #ifdef WITH_NTLM
     copy->ntlm_challenge = NULL;
 #endif
     copy->nlist = NULL;
     copy->blist = NULL;
     copy->clist = NULL;
     copy->alist = NULL;
     copy->attributes = NULL;
     copy->labbuf = NULL;
     copy->lablen = 0;
     copy->labidx = 0;
     copy->namespaces = soap->local_namespaces;
     copy->local_namespaces = NULL;
     soap_set_local_namespaces(copy); /* copy content of soap->local_namespaces */
     copy->namespaces = soap->namespaces; /* point to shared read-only namespaces table */
     copy->c_locale = NULL;
 #ifdef WITH_OPENSSL
     copy->bio = NULL;
     copy->ssl = NULL;
     copy->session = NULL;
     copy->session_host[0] = '\0';
     copy->session_port = 443;
 #endif
 #ifdef WITH_GNUTLS
     copy->session = NULL;
 #endif
 #ifdef WITH_ZLIB
     copy->d_stream = NULL;
     copy->z_buf = NULL;
 #endif
 #ifndef WITH_NOIDREF
     soap_init_iht(copy);
 #endif
     soap_init_pht(copy);
     copy->header = NULL;
     copy->fault = NULL;
     copy->action = NULL;
 #ifndef WITH_LEAN
 #ifdef WITH_COOKIES
     copy->cookies = soap_copy_cookies(copy, soap);
 #else
     copy->cookies = NULL;
 #endif
 #endif
     copy->plugins = NULL;
     for (p = soap->plugins; p; p = p->next)
     {
       struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(copy, sizeof(struct soap_plugin));
       if (!q)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not allocate plugin '%s'\n", p->id));
         soap_end(copy);
         soap_done(copy);
         return NULL;
       }
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying plugin '%s'\n", p->id));
       *q = *p;
       if (p->fcopy && (copy->error = p->fcopy(copy, q, p)) != SOAP_OK)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not copy plugin '%s' error = %d\n", p->id, copy->error));
         SOAP_FREE(copy, q);
         soap_end(copy);
         soap_done(copy);
         return NULL;
       }
       q->next = copy->plugins;
       copy->plugins = q;
     }
   }
 #ifdef WITH_SELF_PIPE
   pipe(copy->pipe_fd);
   SOAP_SOCKNONBLOCK(copy->pipe_fd[0])
   SOAP_SOCKNONBLOCK(copy->pipe_fd[1])
 #endif
   return copy;
 }

References const, detail::copy(), DBGLOG, soap_plugin::fcopy, soap::fdebug, soap_plugin::id, soap::local_namespaces, soap::logfile, soap::namespaces, soap_plugin::next, NULL, soap::plugins, soap_check_state, SOAP_COPY, soap_done(), soap_end(), SOAP_FREE, SOAP_INDEX_RECV, SOAP_INDEX_SENT, SOAP_INDEX_TEST, soap_init_iht(), soap_init_pht(), SOAP_MALLOC, soap_memcpy, SOAP_OK, soap_set_local_namespaces(), soap_set_recv_logfile(), soap_set_sent_logfile(), soap_set_test_logfile(), SOAP_SOCKNONBLOCK, and TEST().

Referenced by soap_copy().

◆ soap_copy_stream()

SOAP_FMAC1 void SOAP_FMAC2 soap_copy_stream	(	struct soap *	copy,
		struct soap *	soap
	)

Definition at line 11828 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp = NULL, *tq;
   if (copy == soap)
     return;
   copy->header = soap->header;
   copy->mode = soap->mode;
   copy->imode = soap->imode;
   copy->omode = soap->omode;
   copy->socket = soap->socket;
   copy->sendsk = soap->sendsk;
   copy->recvsk = soap->recvsk;
   copy->transfer_timeout = soap->transfer_timeout;
   copy->recv_maxlength = soap->recv_maxlength;
   copy->recv_timeout = soap->recv_timeout;
   copy->send_timeout = soap->send_timeout;
   copy->connect_timeout = soap->connect_timeout;
   copy->accept_timeout = soap->accept_timeout;
   copy->socket_flags = soap->socket_flags;
   copy->connect_flags = soap->connect_flags;
   copy->connect_retry = soap->connect_retry;
   copy->bind_flags = soap->bind_flags;
   copy->bind_inet6 = soap->bind_inet6;
   copy->bind_v6only = soap->bind_v6only;
   copy->accept_flags = soap->accept_flags;
   copy->sndbuf = soap->sndbuf;
   copy->rcvbuf = soap->rcvbuf;
   copy->linger_time = soap->linger_time;
   copy->maxlevel = soap->maxlevel;
   copy->maxlength = soap->maxlength;
   copy->maxoccurs = soap->maxoccurs;
   copy->os = soap->os;
   copy->is = soap->is;
   copy->sendfd = soap->sendfd;
   copy->recvfd = soap->recvfd;
   copy->bufidx = soap->bufidx;
   copy->buflen = soap->buflen;
   copy->ahead = soap->ahead;
   copy->cdata = soap->cdata;
   copy->chunksize = soap->chunksize;
   copy->chunkbuflen = soap->chunkbuflen;
   copy->keep_alive = soap->keep_alive;
   copy->tcp_keep_alive = soap->tcp_keep_alive;
   copy->tcp_keep_idle = soap->tcp_keep_idle;
   copy->tcp_keep_intvl = soap->tcp_keep_intvl;
   copy->tcp_keep_cnt = soap->tcp_keep_cnt;
   copy->max_keep_alive = soap->max_keep_alive;
 #ifndef WITH_NOIO
   copy->peer = soap->peer;
   copy->peerlen = soap->peerlen;
   copy->ip = soap->ip;
   copy->ip6[0] = soap->ip6[0];
   copy->ip6[1] = soap->ip6[1];
   copy->ip6[2] = soap->ip6[2];
   copy->ip6[3] = soap->ip6[3];
   copy->port = soap->port;
   (void)soap_memcpy((void*)copy->host, sizeof(copy->host), (const void*)soap->host, sizeof(soap->host));
   (void)soap_memcpy((void*)copy->endpoint, sizeof(copy->endpoint), (const void*)soap->endpoint, sizeof(soap->endpoint));
 #endif
 #ifdef WITH_OPENSSL
   copy->bio = soap->bio;
   copy->ctx = soap->ctx;
   copy->ssl = soap->ssl;
 #endif
 #ifdef WITH_GNUTLS
   copy->session = soap->session;
 #endif
 #ifdef WITH_SYSTEMSSL
   copy->ctx = soap->ctx;
   copy->ssl = soap->ssl;
 #endif
 #ifdef WITH_ZLIB
   copy->zlib_state = soap->zlib_state;
   copy->zlib_in = soap->zlib_in;
   copy->zlib_out = soap->zlib_out;
   if (soap->d_stream && soap->zlib_state != SOAP_ZLIB_NONE)
   {
     if (!copy->d_stream)
       copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
     if (copy->d_stream)
       (void)soap_memcpy((void*)copy->d_stream, sizeof(z_stream), (const void*)soap->d_stream, sizeof(z_stream));
   }
   copy->z_crc = soap->z_crc;
   copy->z_ratio_in = soap->z_ratio_in;
   copy->z_ratio_out = soap->z_ratio_out;
   copy->z_level = soap->z_level;
   if (soap->z_buf && soap->zlib_state != SOAP_ZLIB_NONE)
   {
     if (!copy->z_buf)
       copy->z_buf = (char*)SOAP_MALLOC(copy, sizeof(soap->buf));
     if (copy->z_buf)
       (void)soap_memcpy((void*)copy->z_buf, sizeof(soap->buf), (const void*)soap->z_buf, sizeof(soap->buf));
     else
       copy->z_buflen = 0;
   }
   else
   {
     copy->z_buf = NULL;
     copy->z_buflen = 0;
   }
   copy->z_dict = soap->z_dict;
   copy->z_dict_len = soap->z_dict_len;
 #endif
   (void)soap_memcpy((void*)copy->buf, sizeof(copy->buf), (const void*)soap->buf, sizeof(soap->buf));
   /* copy XML parser state */
   soap_free_ns(copy);
   soap_set_local_namespaces(copy);
   copy->version = soap->version;
   if (soap->nlist && soap->local_namespaces)
   {
     struct soap_nlist *np = NULL, *nq;
     /* copy reversed nlist */
     for (nq = soap->nlist; nq; nq = nq->next)
     {
       struct soap_nlist *nr = np;
       size_t n = sizeof(struct soap_nlist) + strlen(nq->id);
       np = (struct soap_nlist*)SOAP_MALLOC(copy, n);
       if (!np)
       {
         np = nr;
         break;
       }
       (void)soap_memcpy((void*)np, n, (const void*)nq, n);
       np->next = nr;
     }
     while (np)
     {
       const char *s = np->ns;
       copy->level = np->level; /* preserve element nesting level */
       if (!s && np->index >= 0)
       {
         s = soap->local_namespaces[np->index].out;
         if (!s)
           s = soap->local_namespaces[np->index].ns;
       }
       if (s)
         (void)soap_push_namespace(copy, np->id, s);
       nq = np;
       np = np->next;
       SOAP_FREE(copy, nq);
     }
   }
   (void)soap_memcpy((void*)copy->tag, sizeof(copy->tag), (const void*)soap->tag, sizeof(soap->tag));
   (void)soap_memcpy((void*)copy->id, sizeof(copy->id), (const void*)soap->id, sizeof(soap->id));
   (void)soap_memcpy((void*)copy->href, sizeof(copy->href), (const void*)soap->href, sizeof(soap->href));
   (void)soap_memcpy((void*)copy->type, sizeof(copy->type), (const void*)soap->type, sizeof(soap->type));
   copy->other = soap->other;
   copy->root = soap->root;
   copy->null = soap->null;
   copy->body = soap->body;
   copy->part = soap->part;
   copy->mustUnderstand = soap->mustUnderstand;
   copy->level = soap->level;
   copy->peeked = soap->peeked;
   /* copy attributes */
   for (tq = soap->attributes; tq; tq = tq->next)
   {
     struct soap_attribute *tr = tp;
     size_t n = sizeof(struct soap_attribute) + strlen(tq->name);
     tp = (struct soap_attribute*)SOAP_MALLOC(copy, n);
     (void)soap_memcpy((void*)tp, n, (const void*)tq, n);
     if (tp->size)
     {
       tp->value = (char*)SOAP_MALLOC(copy, tp->size);
       if (tp->value)
         (void)soap_memcpy((void*)tp->value, tp->size, (const void*)tq->value, tp->size);
     }
     tp->ns = NULL;
     tp->next = tr;
   }
   copy->attributes = tp;
 }

References soap::accept_flags, soap::accept_timeout, soap::ahead, soap::attributes, soap::bind_flags, soap::bind_inet6, soap::bind_v6only, soap::bio, soap::body, soap::buf, soap::bufidx, soap::buflen, soap::cdata, soap::chunkbuflen, soap::chunksize, soap::connect_flags, soap::connect_retry, soap::connect_timeout, detail::copy(), soap::ctx, soap::d_stream, soap::endpoint, soap::header, soap::host, soap::href, soap_nlist::id, soap::id, soap::imode, soap_nlist::index, soap::ip, soap::ip6, soap::is, soap::keep_alive, soap_nlist::level, soap::level, soap::linger_time, soap::local_namespaces, soap::max_keep_alive, soap::maxlength, soap::maxlevel, soap::maxoccurs, soap::mode, soap::mustUnderstand, soap_attribute::name, soap_nlist::next, soap_attribute::next, soap::nlist, Namespace::ns, soap_nlist::ns, soap::null, NULL, soap::omode, soap::os, soap::other, Namespace::out, soap::part, soap::peeked, soap::peer, soap::peerlen, soap::port, soap::rcvbuf, soap::recv_maxlength, soap::recv_timeout, soap::recvfd, soap::recvsk, soap::root, soap::send_timeout, soap::sendfd, soap::sendsk, soap::session, soap::sndbuf, SOAP_FREE, soap_free_ns(), SOAP_MALLOC, soap_memcpy, soap_push_namespace(), soap_set_local_namespaces(), SOAP_ZLIB_NONE, soap::socket, soap::socket_flags, soap::ssl, soap::tag, soap::tcp_keep_alive, soap::tcp_keep_cnt, soap::tcp_keep_idle, soap::tcp_keep_intvl, soap::transfer_timeout, soap::type, soap_attribute::value, soap::version, soap::z_buf, soap::z_crc, soap::z_dict, soap::z_dict_len, soap::z_level, soap::z_ratio_in, soap::z_ratio_out, soap::zlib_in, soap::zlib_out, and soap::zlib_state.

◆ soap_current_namespace_att()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_current_namespace_att	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 3694 of file stdsoap2.cpp.

 {
   struct soap_nlist *np;
   const char *s;
   if (!tag || !strncmp(tag, "xml", 3))
     return NULL;
   s = strchr(tag, ':');
   if (!s)
     return NULL;
   np = soap->nlist;
   while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag]))
     np = np->next;
   if (!np)
     soap->error = SOAP_NAMESPACE;
   if (np)
   {
     if (np->index >= 0)
       return soap->namespaces[np->index].ns;
     if (np->ns && *np->ns)
       return soap_strdup(soap, np->ns);
   }
   return NULL;
 }

References soap::error, soap_nlist::id, soap_nlist::index, soap::namespaces, soap_nlist::next, soap::nlist, Namespace::ns, soap_nlist::ns, NULL, SOAP_NAMESPACE, and soap_strdup().

Referenced by soap_peek_element().

◆ soap_current_namespace_tag()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_current_namespace_tag	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 3650 of file stdsoap2.cpp.

 {
   struct soap_nlist *np;
   const char *s;
   if (!tag || !strncmp(tag, "xml", 3))
     return NULL;
   np = soap->nlist;
   s = strchr(tag, ':');
   if (!s)
   {
     while (np && *np->id) /* find default namespace, if present */
       np = np->next;
   }
   else
   {
     while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag]))
       np = np->next;
     if (!np)
       soap->error = SOAP_NAMESPACE;
   }
   if (np)
   {
     if (np->index >= 0)
       return soap->namespaces[np->index].ns;
     if (np->ns)
     {
       s = np->ns;
       if (*s)
         return soap_strdup(soap, s);
       do
         np = np->next;
       while (np && *np->id); /* find if there is any other default namespace */
       if (np)
         return soap_strdup(soap, s);
     }
   }
   return NULL;
 }

References soap::error, soap_nlist::id, soap_nlist::index, soap::namespaces, soap_nlist::next, soap::nlist, Namespace::ns, soap_nlist::ns, NULL, SOAP_NAMESPACE, and soap_strdup().

Referenced by soap_peek_element().

◆ soap_dateTime2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_dateTime2s	(	struct soap *	soap,
		time_t	n
	)

Definition at line 18561 of file stdsoap2.cpp.

 {
   struct tm T, *pT = &T;
   size_t l = 0;
 #if defined(HAVE_GMTIME_R) && !defined(WITH_NOZONE)
   if (gmtime_r(&n, pT) != SOAP_FUNC_R_ERR)
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
 #elif defined(HAVE_GMTIME) && !defined(WITH_NOZONE)
   pT = gmtime(&n);
   if (pT)
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
 #elif (defined(HAVE_TM_GMTOFF) || defined(HAVE_STRUCT_TM_TM_GMTOFF) || defined(HAVE_STRUCT_TM___TM_GMTOFF)) && !defined(WITH_NOZONE)
 #if defined(HAVE_LOCALTIME_R)
   if (localtime_r(&n, pT) != SOAP_FUNC_R_ERR)
   {
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S%z", pT);
     if (l)
     {
       (void)soap_memmove(soap->tmpbuf + 23, sizeof(soap->tmpbuf) - 23, soap->tmpbuf + 22, 3); /* 2000-03-01T02:00:00+0300 */
       soap->tmpbuf[22] = ':';                                                           /* 2000-03-01T02:00:00+03:00 */
     }
   }
 #else
   pT = localtime(&n);
   if (pT)
   {
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S%z", pT);
     if (l)
     {
       (void)soap_memmove(soap->tmpbuf + 23, sizeof(soap->tmpbuf) - 23, soap->tmpbuf + 22, 3); /* 2000-03-01T02:00:00+0300 */
       soap->tmpbuf[22] = ':';                                                           /* 2000-03-01T02:00:00+03:00 */
     }
   }
 #endif
 #elif defined(HAVE_GETTIMEOFDAY) && !defined(WITH_NOZONE)
 #if defined(HAVE_LOCALTIME_R)
   if (localtime_r(&n, pT) != SOAP_FUNC_R_ERR)
   {
     struct timeval tv;
     struct timezone tz;
     memset((void*)&tz, 0, sizeof(tz));
     gettimeofday(&tv, &tz);
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
     if (l)
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, 7), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
   }
 #else
   pT = localtime(&n);
   if (pT)
   {
     struct timeval tv;
     struct timezone tz;
     memset((void*)&tz, 0, sizeof(tz));
     gettimeofday(&tv, &tz);
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
     if (l)
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, 7), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
   }
 #endif
 #elif defined(HAVE_FTIME) && !defined(WITH_NOZONE)
 #if defined(HAVE_LOCALTIME_R)
   if (localtime_r(&n, pT) != SOAP_FUNC_R_ERR)
   {
     struct timeb t;
     memset((void*)&t, 0, sizeof(t));
 #ifdef __BORLANDC__
     ::ftime(&t);
 #else
     ftime(&t);
 #endif
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
     if (l)
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, 7), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
   }
 #else
   pT = localtime(&n);
   if (pT)
   {
     struct timeb t;
     memset((void*)&t, 0, sizeof(t));
 #ifdef __BORLANDC__
     ::ftime(&t);
 #else
     ftime(&t);
 #endif
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
     if (l)
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, 7), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
   }
 #endif
 #elif defined(HAVE_LOCALTIME_R)
   if (localtime_r(&n, pT) != SOAP_FUNC_R_ERR)
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
 #else
   pT = localtime(&n);
   if (pT)
     l = strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
 #endif
   if (!l)
     soap_strcpy(soap->tmpbuf, sizeof(soap->tmpbuf), "1969-12-31T23:59:59Z");
   return soap->tmpbuf;
 }

References abs(), gmtime(), detail::gmtime_r(), mpq::l, localtime(), localtime_r(), memset, SOAP_FUNC_R_ERR, soap_memmove, SOAP_SNPRINTF, soap_strcpy, strftime(), and soap::tmpbuf.

Referenced by soap_outdateTime().

◆ soap_dealloc()

SOAP_FMAC1 void SOAP_FMAC2 soap_dealloc	(	struct soap *	soap,
		void *	p
	)

Definition at line 10560 of file stdsoap2.cpp.

 {
   if (soap_check_state(soap))
     return;
   if (p)
   {
     char **q;
     for (q = (char**)(void*)&soap->alist; *q; q = *(char***)q)
     {
       if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
       {
 #ifdef SOAP_MEM_DEBUG
         fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
 #endif
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
         DBGHEX(TEST, *q - 200, 200);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
         soap->error = SOAP_MOE;
         return;
       }
       if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
       {
         *q = **(char***)q;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Freed data at %p\n", p));
         SOAP_FREE(soap, p);
         return;
       }
     }
     soap_delete(soap, p);
   }
   else
   {
     char *q;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free all soap_malloc() data\n"));
     while (soap->alist)
     {
       q = (char*)soap->alist;
       if (*(unsigned short*)(char*)(q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
       {
 #ifdef SOAP_MEM_DEBUG
         fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
 #endif
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
         DBGHEX(TEST, q - 200, 200);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
         soap->error = SOAP_MOE;
         return;
       }
       soap->alist = *(void**)q;
       q -= *(size_t*)(q + sizeof(void*));
       SOAP_FREE(soap, q);
     }
     /* assume these were deallocated: */
     soap->http_content = NULL;
     soap->action = NULL;
     soap->fault = NULL;
     soap->header = NULL;
     soap->bearer = NULL;
     soap->userid = NULL;
     soap->passwd = NULL;
     soap->authrealm = NULL;
 #ifdef WITH_NTLM
     soap->ntlm_challenge = NULL;
 #endif
 #ifndef WITH_LEANER
     soap_clr_mime(soap);
 #endif
   }
 }

References soap::action, soap::alist, soap::authrealm, soap::bearer, DBGHEX, DBGLOG, soap::error, soap::fault, fprintf(), soap::header, soap::http_content, if(), soap::ntlm_challenge, NULL, soap::passwd, SOAP_CANARY, soap_check_state, soap_clr_mime(), soap_delete(), SOAP_FREE, SOAP_MOE, TEST(), and soap::userid.

Referenced by soap_end().

◆ soap_decode_key()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_decode_key	(	char *	buf,
		size_t	len,
		const char *	val
	)

Definition at line 7883 of file stdsoap2.cpp.

 {
   return soap_decode(buf, len, val, "=,;");
 }

References soap_decode().

Referenced by soap_http_header_attribute().

◆ soap_decode_val()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_decode_val	(	char *	buf,
		size_t	len,
		const char *	val
	)

Definition at line 7895 of file stdsoap2.cpp.

 {
   if (*val != '=')
   {
     *buf = '\0';
     return val;
   }
   return soap_decode(buf, len, val + 1, ",;");
 }

References soap_decode().

Referenced by soap_http_header_attribute().

◆ soap_del()

SOAP_FMAC1 void SOAP_FMAC2 soap_del ( struct soap * soap )

Definition at line 9597 of file stdsoap2.cpp.

 {
   free(soap);
 }

◆ soap_del_xsd__anyAttribute()

SOAP_FMAC1 void SOAP_FMAC2 soap_del_xsd__anyAttribute ( const struct soap_dom_attribute * a )

◆ soap_del_xsd__anyType()

SOAP_FMAC1 void SOAP_FMAC2 soap_del_xsd__anyType ( const struct soap_dom_element * a )

◆ soap_delegate_deletion()

SOAP_FMAC1 void SOAP_FMAC2 soap_delegate_deletion	(	struct soap *	soap,
		struct soap *	soap_to
	)

Definition at line 10689 of file stdsoap2.cpp.

 {
   struct soap_clist *cp;
   char **q;
 #ifdef SOAP_MEM_DEBUG
   void *p;
   struct soap_mlist **mp, *mq;
   size_t h;
 #endif
   for (q = (char**)(void*)&soap->alist; *q; q = *(char***)q)
   {
     if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
     {
 #ifdef SOAP_MEM_DEBUG
       fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
 #endif
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
       DBGHEX(TEST, *q - 200, 200);
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
       soap->error = SOAP_MOE;
       return;
     }
 #ifdef SOAP_MEM_DEBUG
     p = (void*)(*q - *(size_t*)(*q + sizeof(void*)));
     h = soap_hash_ptr(p);
     for (mp = &soap->mht[h]; *mp; mp = &(*mp)->next)
     {
       if ((*mp)->ptr == p)
       {
         mq = *mp;
         *mp = mq->next;
         mq->next = soap_to->mht[h];
         soap_to->mht[h] = mq;
         break;
       }
     }
 #endif
   }
   *q = (char*)soap_to->alist;
   soap_to->alist = soap->alist;
   soap->alist = NULL;
 #ifdef SOAP_MEM_DEBUG
   cp = soap->clist;
   while (cp)
   {
     h = soap_hash_ptr(cp);
     for (mp = &soap->mht[h]; *mp; mp = &(*mp)->next)
     {
       if ((*mp)->ptr == cp)
       {
         mq = *mp;
         *mp = mq->next;
         mq->next = soap_to->mht[h];
         soap_to->mht[h] = mq;
         break;
       }
     }
     cp = cp->next;
   }
 #endif
   cp = soap_to->clist;
   if (cp)
   {
     while (cp->next)
       cp = cp->next;
     cp->next = soap->clist;
   }
   else
   {
     soap_to->clist = soap->clist;
   }
   soap->clist = NULL;
 }

References soap::alist, soap::clist, DBGHEX, DBGLOG, soap::error, fprintf(), soap::mht, soap_clist::next, NULL, SOAP_CANARY, soap_hash_ptr, SOAP_MOE, and TEST().

◆ soap_DELETE()

SOAP_FMAC1 int SOAP_FMAC2 soap_DELETE	(	struct soap *	soap,
		const char *	endpoint
	)

Definition at line 21315 of file stdsoap2.cpp.

 {
   if (soap_connect_command(soap, SOAP_DEL, endpoint, NULL)
    || soap_recv_empty_response(soap))
     return soap_closesock(soap);
   return SOAP_OK;
 }

References NULL, soap_closesock(), soap_connect_command(), SOAP_DEL, SOAP_OK, and soap_recv_empty_response().

◆ soap_delete()

SOAP_FMAC1 void SOAP_FMAC2 soap_delete	(	struct soap *	soap,
		void *	p
	)

Definition at line 10635 of file stdsoap2.cpp.

 {
   struct soap_clist **cp;
   if (soap_check_state(soap))
     return;
   cp = &soap->clist;
   if (p)
   {
     while (*cp)
     {
       if (p == (*cp)->ptr)
       {
         struct soap_clist *q = *cp;
         *cp = q->next;
         if (q->fdelete(soap, q))
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type=%d\n", q->ptr, q->type));
 #ifdef SOAP_MEM_DEBUG
           fprintf(stderr, "new(object type=%d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
 #endif
         }
         SOAP_FREE(soap, q);
         return;
       }
       cp = &(*cp)->next;
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: address not in list\n", p));
   }
   else
   {
     while (*cp)
     {
       struct soap_clist *q = *cp;
       *cp = q->next;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Delete %p type=%d (cp=%p)\n", q->ptr, q->type, (void*)q));
       if (q->fdelete(soap, q))
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type=%d\n", q->ptr, q->type));
 #ifdef SOAP_MEM_DEBUG
         fprintf(stderr, "new(object type=%d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
 #endif
       }
       SOAP_FREE(soap, q);
     }
   }
   soap->fault = NULL; /* assume this was deallocated */
   soap->header = NULL; /* assume this was deallocated */
 }

References soap::clist, DBGLOG, soap::fault, soap_clist::fdelete, fprintf(), soap::header, soap_clist::next, NULL, soap_clist::ptr, soap_check_state, SOAP_FREE, TEST(), and soap_clist::type.

Referenced by soap_dealloc().

◆ soap_dime_option()

SOAP_FMAC1 char* SOAP_FMAC2 soap_dime_option	(	struct soap *	soap,
		unsigned short	optype,
		const char *	option
	)

Definition at line 19176 of file stdsoap2.cpp.

 {
   size_t n;
   char *s = NULL;
   if (option)
   {
     n = strlen(option);
     s = (char*)soap_malloc(soap, n + 5);
     if (s)
     {
       s[0] = (char)(optype >> 8);
       s[1] = (char)(optype & 0xFF);
       s[2] = (char)(n >> 8);
       s[3] = (char)(n & 0xFF);
       soap_strcpy(s + 4, n + 1, option);
     }
   }
   return s;
 }

References NULL, soap_malloc(), and soap_strcpy.

Referenced by soap_set_dime_attachment().

◆ soap_dom_call()

SOAP_FMAC1 int SOAP_FMAC2 soap_dom_call	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action,
		const struct soap_dom_element *	in,
		struct soap_dom_element *	out
	)

◆ soap_dom_find()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_dom_find	(	struct soap_dom_element *	begin,
		const struct soap_dom_element *	end,
		const char *	ns,
		const char *	patt,
		int	type
	)

◆ soap_dom_find_next()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_dom_find_next	(	const struct soap_dom_element *	elt,
		const struct soap_dom_element *	end,
		const char *	ns,
		const char *	patt,
		int	type
	)

◆ soap_dom_next_attribute()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_dom_next_attribute ( const struct soap_dom_attribute * att )

◆ soap_dom_next_element()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_dom_next_element	(	const struct soap_dom_element *	elt,
		const struct soap_dom_element *	end
	)

◆ soap_done()

SOAP_FMAC1 void SOAP_FMAC2 soap_done ( struct soap * soap )

Definition at line 7280 of file stdsoap2.cpp.

 {
 #ifdef SOAP_DEBUG
   int i;
 #endif
   if (soap_check_state(soap))
     return;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Done with context%s\n", soap->state == SOAP_COPY ? " copy" : ""));
   soap_free_temp(soap);
 #ifdef SOAP_DEBUG
   if (soap->clist)
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Warning: managed C++ data was not deallocated with soap_destroy() from the heap managed by context %p\n", (void*)soap));
   if (soap->alist)
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Warning: managed C data was not deallocated with soap_end() from the heap managed by context %p\n", (void*)soap));
 #endif
   soap->alist = NULL;
   while (soap->clist)
   {
     struct soap_clist *p = soap->clist->next;
     SOAP_FREE(soap, soap->clist);
     soap->clist = p;
   }
   if (soap->state == SOAP_INIT)
     soap->omode &= ~SOAP_IO_UDP; /* to force close the socket */
   soap->keep_alive = 0; /* to force close the socket */
   if (soap->master == soap->socket) /* do not close twice */
     soap->master = SOAP_INVALID_SOCKET;
   soap_closesock(soap);
 #ifdef WITH_COOKIES
   soap_free_cookies(soap);
 #endif
   while (soap->plugins)
   {
     struct soap_plugin *p = soap->plugins->next;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Removing plugin '%s'\n", soap->plugins->id));
     if (soap->plugins->fcopy || soap->state == SOAP_INIT)
       soap->plugins->fdelete(soap, soap->plugins);
     SOAP_FREE(soap, soap->plugins);
     soap->plugins = p;
   }
   soap->fplugin = fplugin;
 #ifndef WITH_NOHTTP
   soap->fpost = http_post;
   soap->fget = http_get;
   soap->fput = http_put;
   soap->fpatch = http_patch;
   soap->fdel = http_del;
   soap->fopt = http_200;
   soap->fhead = http_200;
   soap->fform = NULL;
   soap->fposthdr = http_post_header;
   soap->fresponse = http_response;
   soap->fparse = http_parse;
   soap->fparsehdr = http_parse_header;
 #endif
   soap->fheader = NULL;
 #ifndef WITH_NOIO
 #ifndef WITH_IPV6
   soap->fresolve = tcp_gethost;
 #else
   soap->fresolve = NULL;
 #endif
   soap->faccept = tcp_accept;
   soap->fopen = tcp_connect;
   soap->fclose = tcp_disconnect;
   soap->fclosesocket = tcp_closesocket;
   soap->fshutdownsocket = tcp_shutdownsocket;
   soap->fsend = fsend;
   soap->frecv = frecv;
   soap->fpoll = soap_poll;
 #else
   soap->fopen = NULL;
   soap->fclose = NULL;
   soap->fpoll = NULL;
 #endif
 #ifndef WITH_LEANER
   soap->fsvalidate = NULL;
   soap->fwvalidate = NULL;
   soap->feltbegin = NULL;
   soap->feltendin = NULL;
   soap->feltbegout = NULL;
   soap->feltendout = NULL;
   soap->fprepareinitsend = NULL;
   soap->fprepareinitrecv = NULL;
   soap->fpreparesend = NULL;
   soap->fpreparerecv = NULL;
   soap->fpreparefinalsend = NULL;
   soap->fpreparefinalrecv = NULL;
   soap->ffiltersend = NULL;
   soap->ffilterrecv = NULL;
 #endif
   soap->fseterror = NULL;
   soap->fignore = NULL;
   soap->fserveloop = NULL;
 #ifdef WITH_OPENSSL
   if (soap->session)
   {
     SSL_SESSION_free(soap->session);
     soap->session = NULL;
   }
 #endif
   if (soap->state == SOAP_INIT)
   {
     if (soap_valid_socket(soap->master))
     {
       soap->fclosesocket(soap, soap->master);
       soap->master = SOAP_INVALID_SOCKET;
     }
   }
 #ifdef WITH_OPENSSL
   if (soap->ssl)
   {
     SSL_free(soap->ssl);
     soap->ssl = NULL;
   }
   if (soap->state == SOAP_INIT)
   {
     if (soap->ctx)
     {
       SSL_CTX_free(soap->ctx);
       soap->ctx = NULL;
     }
   }
   ERR_clear_error();
 # if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
   /* OpenSSL libraries handle thread init and deinit */
 # elif OPENSSL_VERSION_NUMBER >= 0x10000000L
   ERR_remove_thread_state(NULL);
 # else
   ERR_remove_state(0);
 # endif
 #endif
 #ifdef WITH_GNUTLS
   if (soap->state == SOAP_INIT)
   {
     if (soap->xcred)
     {
       gnutls_certificate_free_credentials(soap->xcred);
       soap->xcred = NULL;
     }
     if (soap->acred)
     {
       gnutls_anon_free_client_credentials(soap->acred);
       soap->acred = NULL;
     }
     if (soap->cache)
     {
       gnutls_priority_deinit(soap->cache);
       soap->cache = NULL;
     }
     if (soap->dh_params)
     {
       gnutls_dh_params_deinit(soap->dh_params);
       soap->dh_params = NULL;
     }
 # if GNUTLS_VERSION_NUMBER < 0x030300
     if (soap->rsa_params)
     {
       gnutls_rsa_params_deinit(soap->rsa_params);
       soap->rsa_params = NULL;
     }
 #endif
   }
   if (soap->session)
   {
     gnutls_deinit(soap->session);
     soap->session = NULL;
   }
 #endif
 #ifdef WITH_SYSTEMSSL
   if (soap->ssl)
     gsk_secure_socket_close(&soap->ssl);
   if (soap->state == SOAP_INIT)
     if (soap->ctx)
       gsk_environment_close(&soap->ctx);
 #endif
 #ifdef WITH_C_LOCALE
   SOAP_FREELOCALE(soap);
 #endif
 #ifdef WITH_ZLIB
   if (soap->d_stream)
   {
     SOAP_FREE(soap, soap->d_stream);
     soap->d_stream = NULL;
   }
   if (soap->z_buf)
   {
     SOAP_FREE(soap, soap->z_buf);
     soap->z_buf = NULL;
   }
 #endif
 #ifdef SOAP_DEBUG
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free logfiles\n"));
   for (i = 0; i < SOAP_MAXLOGS; i++)
   {
     soap_close_logfile(soap, i);
     if (soap->logfile[i])
     {
       SOAP_FREE_UNMANAGED(soap->logfile[i]);
       soap->logfile[i] = NULL;
     }
   }
 #endif
 #ifdef WITH_SELF_PIPE
   close(soap->pipe_fd[0]);
   close(soap->pipe_fd[1]);
 #endif
 #ifdef SOAP_MEM_DEBUG
   soap_free_mht(soap);
 #endif
   soap->state = SOAP_NONE;
 }

References soap::alist, soap::clist, close, soap::ctx, soap::d_stream, DBGLOG, soap::dh_params, soap::faccept, soap::fclose, soap::fclosesocket, soap_plugin::fcopy, soap::fdel, soap_plugin::fdelete, soap::feltbegin, soap::feltbegout, soap::feltendin, soap::feltendout, soap::ffilterrecv, soap::ffiltersend, soap::fform, soap::fget, soap::fhead, soap::fheader, soap::fignore, soap::fopen, soap::fopt, soap::fparse, soap::fparsehdr, soap::fpatch, fplugin(), soap::fplugin, soap::fpoll, soap::fpost, soap::fposthdr, soap::fpreparefinalrecv, soap::fpreparefinalsend, soap::fprepareinitrecv, soap::fprepareinitsend, soap::fpreparerecv, soap::fpreparesend, soap::fput, frecv(), soap::frecv, soap::fresolve, soap::fresponse, fsend(), soap::fsend, soap::fserveloop, soap::fseterror, soap::fshutdownsocket, soap::fsvalidate, soap::fwvalidate, http_200(), http_del(), http_get(), http_parse(), http_parse_header(), http_patch(), http_post(), http_post_header(), http_put(), http_response(), soap_plugin::id, soap::keep_alive, soap::logfile, soap::master, soap_clist::next, soap_plugin::next, NULL, soap::omode, soap::plugins, soap::rsa_params, soap::session, soap_check_state, soap_closesock(), SOAP_COPY, SOAP_FREE, soap_free_temp(), SOAP_FREE_UNMANAGED, SOAP_INIT, SOAP_INVALID_SOCKET, SOAP_IO_UDP, SOAP_MAXLOGS, SOAP_NONE, soap_poll(), soap_valid_socket, soap::socket, soap::ssl, soap::state, tcp_accept(), tcp_closesocket(), tcp_connect(), tcp_disconnect(), tcp_gethost(), tcp_shutdownsocket(), TEST(), and soap::z_buf.

Referenced by ACSoapThread(), soap_cleanup(), soap_copy(), soap_copy_context(), and soap_free().

◆ soap_double2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_double2s	(	struct soap *	soap,
		double	n
	)

Definition at line 16767 of file stdsoap2.cpp.

 {
 #if defined(WITH_C_LOCALE)
 # if !defined(WIN32)
   SOAP_LOCALE_T locale;
 # endif
 #else
   char *s;
 #endif
   if (soap_isnan(n))
     return "NaN";
   if (soap_ispinfd(n))
     return "INF";
   if (soap_isninfd(n))
     return "-INF";
 #if defined(WITH_C_LOCALE)
 # ifdef WIN32
   _sprintf_s_l(soap->tmpbuf, _countof(soap->tmpbuf), soap->double_format, SOAP_LOCALE(soap), n);
 # else
   locale = uselocale(SOAP_LOCALE(soap));
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 40), soap->double_format, n);
   uselocale(locale);
 # endif
 #else
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 40), soap->double_format, n);
   s = strchr(soap->tmpbuf, ',');        /* convert decimal comma to DP */
   if (s)
     *s = '.';
 #endif
   return soap->tmpbuf;
 }

References soap::double_format, soap_isnan, soap_isninfd, soap_ispinfd, SOAP_SNPRINTF, and soap::tmpbuf.

Referenced by soap_outdouble().

◆ soap_dup_xsd__anyAttribute()

SOAP_FMAC1 struct soap_dom_attribute* SOAP_FMAC2 soap_dup_xsd__anyAttribute	(	struct soap *	soap,
		struct soap_dom_attribute *	d,
		const struct soap_dom_attribute *	a
	)

◆ soap_dup_xsd__anyType()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_dup_xsd__anyType	(	struct soap *	soap,
		struct soap_dom_element *	d,
		const struct soap_dom_element *	a
	)

◆ soap_element()

SOAP_FMAC1 int SOAP_FMAC2 soap_element	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	type
	)

Definition at line 12763 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEAN
   const char *s;
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' level='%u' id='%d' type='%s'\n", tag, soap->level, id, type ? type : SOAP_STR_EOS));
 #ifdef WITH_DOM
 #ifndef WITH_LEAN
   if (soap_tagsearch(soap->wsuid, tag))
   {
     size_t i;
     for (s = tag, i = 0; *s && i < sizeof(soap->href) - 1; s++, i++)
       soap->href[i] = *s == ':' ? '-' : *s;
     soap->href[i] = '\0';
     if (soap_set_attr(soap, "wsu:Id", soap->href, 1))
       return soap->error;
   }
 #endif
 #endif
   soap->level++;
   if (soap->level > soap->maxlevel)
     return soap->error = SOAP_LEVEL;
 #ifdef WITH_DOM
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_DOM_ASIS))
   {
     if (soap->evlev >= soap->level)
       soap->evlev = 0;
     if (soap->event == SOAP_SEC_BEGIN && !soap->evlev)
     {
       struct soap_nlist *np;
       /* non-nested wsu:Id found: clear xmlns, re-emit them for exc-c14n */
       for (np = soap->nlist; np; np = np->next)
       {
         int p = soap->c14ninclude ? *soap->c14ninclude == '+' || soap_tagsearch(soap->c14ninclude, np->id) != NULL : 0;
         if (np->index == 2 || p)
         {
           struct soap_nlist *np1 = soap_push_ns(soap, np->id, np->ns, 1, 0);
           if (np1 && !p)
             np1->index = 0;
         }
       }
       soap->evlev = soap->level;
     }
   }
 #endif
   if ((soap->mode & SOAP_XML_DOM))
   {
     struct soap_dom_element *elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
     if (!elt)
       return soap->error = SOAP_EOM;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Adding DOM element tag='%s' %p (parent='%s' %p)\n", tag, elt, soap->dom ? soap->dom->name : "(null)", soap->dom));
     elt->soap = soap;
     elt->next = NULL;
     elt->prnt = soap->dom;
     elt->elts = NULL;
     elt->atts = NULL;
     elt->nstr = NULL;
     elt->name = soap_strdup(soap, tag);
     elt->lead = NULL;
     elt->text = NULL;
     elt->code = NULL;
     elt->tail = NULL;
     elt->node = NULL;
     elt->type = 0;
     if (soap->dom)
     {
       struct soap_dom_element *p = soap->dom->elts;
       if (p)
       {
         while (p->next)
           p = p->next;
         p->next = elt;
       }
       else
       {
         soap->dom->elts = elt;
       }
     }
     soap->dom = elt;
     if (!elt->name)
       return soap->error = SOAP_EOM;
   }
   else
   {
 #endif
 #ifndef WITH_LEAN
     if (!soap->ns)
     {
       if (!(soap->mode & SOAP_XML_CANONICAL) && soap_send(soap, soap->prolog))
         return soap->error;
     }
     else if ((soap->mode & SOAP_XML_INDENT))
     {
       if (soap->ns == 1 && soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
         return soap->error;
       soap->body = 1;
     }
     if ((soap->mode & SOAP_XML_DEFAULTNS))
     {
       size_t n = 0;
       s = strchr(tag, ':');
       if (s)
         n = s++ - tag;
       else
         s = tag;
       if (soap_send_raw(soap, "<", 1)
        || soap_send(soap, s))
         return soap->error;
       if (n)
       {
         struct Namespace *ns = soap->local_namespaces;
         for (; ns && ns->id; ns++)
         {
           if (*ns->id && ns->ns && !strncmp(ns->id, tag, n) && !ns->id[n])
           {
             if (!soap->nlist || *soap->nlist->id || (soap->nlist->ns && strcmp(soap->nlist->ns, ns->ns)))
             {
               (void)soap_push_ns(soap, SOAP_STR_EOS, ns->out ? ns->out : ns->ns, 0, 0);
               if (soap_attribute(soap, "xmlns", ns->out ? ns->out : ns->ns))
                 return soap->error;
             }
             break;
           }
         }
       }
 #ifndef WITH_NOEMPTYNAMESPACES
       else if (!soap->nlist || *soap->nlist->id || (soap->nlist->ns && *soap->nlist->ns))
       {
         (void)soap_push_ns(soap, SOAP_STR_EOS, SOAP_STR_EOS, 0, 0);
         if (soap_attribute(soap, "xmlns", SOAP_STR_EOS))
           return soap->error;
       }
 #endif
     }
     else
 #endif
     if (soap_send_raw(soap, "<", 1)
      || soap_send(soap, tag))
       return soap->error;
 #ifdef WITH_DOM
   }
 #endif
   if (!soap->ns)
   {
     struct Namespace *ns = soap->local_namespaces;
     int k = -1;
     if (ns)
     {
       while (k-- && ns->id)
       {
         const char *t = ns->out;
         if (!t)
           t = ns->ns;
         if (*ns->id && t && *t)
         {
           (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), strlen(ns->id) + 6), "xmlns:%s", ns->id);
           if (soap_attribute(soap, soap->tmpbuf, t))
             return soap->error;
         }
         ns++;
       }
     }
   }
   soap->ns = 1; /* namespace table control: ns = 0 or 2 to start, then 1 to stop dumping the table  */
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL))
   {
     if ((soap->mode & SOAP_XML_DEFAULTNS))
       soap_utilize_ns(soap, SOAP_STR_EOS, 0);
     else
       soap_utilize_ns(soap, tag, 0);
   }
 #endif
   if (id > 0)
   {
     (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), sizeof(SOAP_BASEREFNAME) + 20), SOAP_BASEREFNAME "%d", id);
     if (soap->version == 2)
     {
       if (soap_attribute(soap, "SOAP-ENC:id", soap->tmpbuf))
         return soap->error;
     }
     else if (soap_attribute(soap, "id", soap->tmpbuf))
     {
       return soap->error;
     }
   }
   if (type && *type && !(soap->mode & SOAP_XML_NOTYPE))
   {
 #ifndef WITH_LEAN
     if ((soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_XML_CANONICAL_NA))
       soap_utilize_ns(soap, type, 0);
 #endif
     if (soap_attribute(soap, "xsi:type", type))
       return soap->error;
   }
   if (soap->null && soap->position > 0 && soap->version == 1)
   {
     int i;
     (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf) - 1, 20), "[%d", soap->positions[0]);
     for (i = 1; i < soap->position; i++)
     {
       size_t l = strlen(soap->tmpbuf);
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l - 1, 20), ",%d", soap->positions[i]);
     }
     soap_strcat(soap->tmpbuf, sizeof(soap->tmpbuf), "]");
     if (soap_attribute(soap, "SOAP-ENC:position", soap->tmpbuf))
       return soap->error;
   }
   if (soap->mustUnderstand)
   {
     if (soap->actor && *soap->actor)
     {
       if (soap_attribute(soap, soap->version == 2 ? "SOAP-ENV:role" : "SOAP-ENV:actor", soap->actor))
         return soap->error;
     }
     if (soap_attribute(soap, "SOAP-ENV:mustUnderstand", soap->version == 2 ? "true" : "1"))
       return soap->error;
     soap->mustUnderstand = 0;
   }
   if (soap->encoding)
   {
     if (soap->encodingStyle && soap->local_namespaces && soap->local_namespaces[0].id && soap->local_namespaces[1].id)
     {
       if (!*soap->encodingStyle)
       {
         if (soap->local_namespaces[1].out)
           soap->encodingStyle = soap->local_namespaces[1].out;
         else
           soap->encodingStyle = soap->local_namespaces[1].ns;
       }
       if (soap->encodingStyle && soap_attribute(soap, "SOAP-ENV:encodingStyle", soap->encodingStyle))
         return soap->error;
     }
     else
     {
       soap->encodingStyle = NULL;
     }
     soap->encoding = 0;
   }
   soap->null = 0;
   soap->position = 0;
   return SOAP_OK;
 }

References soap::actor, soap_dom_element::atts, soap::body, soap::c14ninclude, soap_dom_element::code, DBGLOG, soap::dom, soap_dom_element::elts, soap::encoding, soap::encodingStyle, soap::error, soap::event, soap::evlev, soap::href, Namespace::id, soap_nlist::id, if(), soap_nlist::index, mpq::l, soap_dom_element::lead, soap::level, soap::local_namespaces, soap::maxlevel, soap::mode, soap::mustUnderstand, soap_dom_element::name, soap_nlist::next, soap_dom_element::next, soap::nlist, soap_dom_element::node, Namespace::ns, soap_nlist::ns, soap::ns, soap_dom_element::nstr, soap::null, NULL, Namespace::out, soap::position, soap::positions, soap_dom_element::prnt, soap::prolog, soap, soap_dom_element::soap, soap_attribute(), SOAP_BASEREFNAME, SOAP_DOM_ASIS, SOAP_EOM, soap_indent, SOAP_LEVEL, soap_malloc(), SOAP_OK, soap_push_ns(), SOAP_SEC_BEGIN, soap_send(), soap_send_raw(), soap_set_attr(), SOAP_SNPRINTF, SOAP_STR_EOS, soap_strcat(), soap_strdup(), soap_tagsearch(), soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_CANONICAL_NA, SOAP_XML_DEFAULTNS, SOAP_XML_DOM, SOAP_XML_INDENT, SOAP_XML_NOTYPE, soap_dom_element::tail, TEST(), soap_dom_element::text, soap::tmpbuf, soap_dom_element::type, soap::version, and soap::wsuid.

Referenced by soap_array_begin_out(), soap_element_begin_out(), soap_element_empty(), soap_element_href(), soap_element_nil(), soap_element_null(), and soap_element_result().

◆ soap_element_begin_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_begin_in	(	struct soap *	soap,
		const char *	tag,
		int	nillable,
		const char *	type
	)

Definition at line 13889 of file stdsoap2.cpp.

 {
   if (!soap_peek_element(soap))
   {
     if (soap->other)
       return soap->error = SOAP_TAG_MISMATCH;
     if (tag && *tag == '-')
       return SOAP_OK;
     soap->error = soap_match_tag(soap, soap->tag, tag);
     if (!soap->error)
     {
       if (type && *soap->type && soap_match_tag(soap, soap->type, type))
         return soap->error = SOAP_TYPE;
       soap->peeked = 0;
       if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT))
         return soap->error = SOAP_NULL;
       if (soap->body)
       {
         soap->level++;
         if (soap->level > soap->maxlevel)
           return soap->error = SOAP_LEVEL;
       }
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin tag found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag ? tag : SOAP_STR_EOS));
       soap->error = SOAP_OK;
     }
   }
   else if (soap->error == SOAP_NO_TAG && tag && *tag == '-')
   {
     soap->error = SOAP_OK;
   }
   return soap->error;
 }

References soap::body, DBGLOG, soap::error, soap::level, soap::maxlevel, soap::mode, soap::null, soap::other, soap::peeked, SOAP_LEVEL, soap_match_tag(), SOAP_NO_TAG, SOAP_NULL, SOAP_OK, soap_peek_element(), SOAP_STR_EOS, SOAP_TAG_MISMATCH, SOAP_TYPE, SOAP_XML_STRICT, soap::tag, TEST(), and soap::type.

Referenced by soap_body_begin_in(), soap_envelope_begin_in(), soap_in_ns1__executeCommand(), soap_in_ns1__executeCommandResponse(), soap_in_PointerToSOAP_ENV__Code(), soap_in_PointerToSOAP_ENV__Detail(), soap_in_PointerToSOAP_ENV__Reason(), soap_in_PointerTostring(), soap_in_SOAP_ENV__Code(), soap_in_SOAP_ENV__Detail(), soap_in_SOAP_ENV__Fault(), soap_in_SOAP_ENV__Header(), soap_in_SOAP_ENV__Reason(), soap_inbyte(), soap_indateTime(), soap_indouble(), soap_infloat(), soap_inint(), soap_inliteral(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_instring(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), soap_inunsignedShort(), soap_inwliteral(), soap_inwstring(), soap_recv_fault(), and soap_xop_forward().

◆ soap_element_begin_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_begin_out	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	type
	)

Definition at line 13013 of file stdsoap2.cpp.

 {
   if (*tag == '-')
     return SOAP_OK;
 #ifdef WITH_DOM
   if (soap->feltbegout)
     return soap->error = soap->feltbegout(soap, tag, id, type);
 #endif
   if (soap_element(soap, tag, id, type))
     return soap->error;
   return soap_element_start_end_out(soap, NULL);
 }

References soap::error, soap::feltbegout, NULL, soap_element(), soap_element_start_end_out(), and SOAP_OK.

Referenced by soap_array_begin_out(), soap_attachment(), soap_body_begin_out(), soap_envelope_begin_out(), soap_out_ns1__executeCommand(), soap_out_ns1__executeCommandResponse(), soap_out_SOAP_ENV__Code(), soap_out_SOAP_ENV__Detail(), soap_out_SOAP_ENV__Fault(), soap_out_SOAP_ENV__Header(), soap_out_SOAP_ENV__Reason(), soap_outbyte(), soap_outdateTime(), soap_outdouble(), soap_outfloat(), soap_outint(), soap_outliteral(), soap_outlong(), soap_outLONG64(), soap_outshort(), soap_outstring(), soap_outULONG64(), soap_outunsignedByte(), soap_outunsignedInt(), soap_outunsignedLong(), soap_outunsignedShort(), soap_outwliteral(), soap_outwstring(), and soap_send_fault().

◆ soap_element_empty()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_empty	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13622 of file stdsoap2.cpp.

 {
   if (soap_element(soap, tag, -1, NULL))
     return soap->error;
   return soap_element_start_end_out(soap, tag);
 }

References soap::error, NULL, soap_element(), and soap_element_start_end_out().

Referenced by soap_putelement().

◆ soap_element_end()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_end	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13515 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEAN
   const char *s;
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag));
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     if (soap->dom->prnt)
       soap->dom = soap->dom->prnt;
     return SOAP_OK;
   }
 #endif
 #ifndef WITH_LEAN
   if (soap->nlist)
     soap_pop_namespace(soap);
   if ((soap->mode & SOAP_XML_INDENT))
   {
     if (!soap->body)
     {
       if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
         return soap->error;
     }
     soap->body = 0;
   }
   if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')) != NULL)
     tag = s + 1;
 #endif
   if (soap_send_raw(soap, "</", 2)
    || soap_send(soap, tag))
     return soap->error;
   soap->level--;        /* decrement level just before > */
   return soap_send_raw(soap, ">", 1);
 }

References soap::body, DBGLOG, soap::dom, soap::error, soap::level, soap::mode, soap::nlist, NULL, soap_dom_element::prnt, soap_indent, SOAP_OK, soap_pop_namespace(), soap_send(), soap_send_raw(), SOAP_XML_DEFAULTNS, SOAP_XML_DOM, SOAP_XML_INDENT, and TEST().

Referenced by soap_element_end_out().

◆ soap_element_end_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_end_in	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13927 of file stdsoap2.cpp.

 {
   soap_wchar c;
   char *s = NULL;
   int n = 0;
   if (tag && *tag == '-')
     return SOAP_OK;
   if (soap->error == SOAP_NO_TAG)
     soap->error = SOAP_OK;
 #ifdef WITH_DOM
   /* this whitespace or mixed content is significant for DOM "as-is" */
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     const char *t = soap->dom->code; /* save XML code */
     s = soap_string_in(soap, -1, -1, -1, NULL);
     if (!soap->peeked && !s)
       return soap->error;
     if (soap->dom->prnt)
       soap->dom = soap->dom->prnt;
     if (s && (soap->mode & SOAP_XML_STRICT))
     {
       for (; *s; s++)
         if (!soap_coblank((soap_wchar)*s))
           return soap->error = SOAP_END_TAG; /* reject mixed content before ending tag */
     }
     soap->dom->code = t; /* restore XML code */
   }
 #endif
   if (soap->peeked)
   {
     if (*soap->tag)
       n++;
     soap->peeked = 0;
   }
   do
   {
     while (((c = soap_get(soap)) != SOAP_TT))
     {
       if ((int)c == EOF)
         return soap->error = SOAP_CHK_EOF;
       if (!soap_coblank(c))
       {
         if ((soap->mode & SOAP_XML_STRICT))
           return soap->error = SOAP_END_TAG; /* reject mixed content before ending tag */
         if (c == SOAP_LT)
           n++;
         else if (c == '/')
         {
           c = soap_get(soap);
           if (c == SOAP_GT && n > 0)
             n--;
           else
             soap_unget(soap, c);
         }
       }
     }
   } while (n-- > 0);
   s = soap->tag;
   n = sizeof(soap->tag);
   while ((c = soap_get(soap)) > 32)
   {
     if (n > 1)
     {
       *s++ = (char)c;
       n--;
     }
   }
   *s = '\0';
   if ((int)c == EOF)
     return soap->error = SOAP_CHK_EOF;
   while (soap_coblank(c))
     c = soap_get(soap);
   if (c != SOAP_GT)
     return soap->error = SOAP_SYNTAX_ERROR;
 #ifndef WITH_LEAN
 #ifdef WITH_DOM
   if (soap->feltendin)
   {
     int err = soap->error;
     soap->error = soap->feltendin(soap, soap->tag, tag);
     if (soap->error)
       return soap->error;
     if (err)
       return soap->error = err; /* restore error */
   }
 #endif
 #endif
   if (tag && (soap->mode & SOAP_XML_STRICT))
   {
     soap_pop_namespace(soap);
     if (soap_match_tag(soap, soap->tag, tag))
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End tag '%s' does not match '%s'\n", soap->tag, tag ? tag : SOAP_STR_EOS));
       return soap->error = SOAP_SYNTAX_ERROR;
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End tag found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag ? tag : SOAP_STR_EOS));
   soap->level--;
   return SOAP_OK;
 }

References mpq::c, soap_dom_element::code, DBGLOG, soap::dom, soap::error, soap::feltendin, soap::level, soap::mode, NULL, soap::peeked, soap_dom_element::prnt, SOAP_CHK_EOF, soap_coblank, SOAP_END_TAG, soap_get(), SOAP_GT, SOAP_LT, soap_match_tag(), SOAP_NO_TAG, SOAP_OK, soap_pop_namespace(), SOAP_STR_EOS, soap_string_in(), SOAP_SYNTAX_ERROR, SOAP_TT, soap_unget, SOAP_XML_DOM, SOAP_XML_STRICT, soap::tag, and TEST().

Referenced by soap_body_end_in(), soap_envelope_end_in(), soap_ignore(), soap_in_ns1__executeCommand(), soap_in_ns1__executeCommandResponse(), soap_in_PointerToSOAP_ENV__Code(), soap_in_PointerToSOAP_ENV__Detail(), soap_in_PointerToSOAP_ENV__Reason(), soap_in_PointerTostring(), soap_in_SOAP_ENV__Code(), soap_in_SOAP_ENV__Detail(), soap_in_SOAP_ENV__Fault(), soap_in_SOAP_ENV__Header(), soap_in_SOAP_ENV__Reason(), soap_inbyte(), soap_indateTime(), soap_indouble(), soap_infloat(), soap_inint(), soap_inliteral(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_instring(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), soap_inunsignedShort(), soap_inwliteral(), soap_inwstring(), soap_recv_fault(), and soap_xop_forward().

◆ soap_element_end_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_end_out	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13499 of file stdsoap2.cpp.

 {
   if (*tag == '-')
     return SOAP_OK;
 #ifdef WITH_DOM
   if (soap->feltendout)
     return soap->error = soap->feltendout(soap, tag);
 #endif
   return soap_element_end(soap, tag);
 }

References soap::error, soap::feltendout, soap_element_end(), and SOAP_OK.

Referenced by soap_attachment(), soap_body_end_out(), soap_element_result(), soap_element_start_end_out(), soap_envelope_end_out(), soap_out_ns1__executeCommand(), soap_out_ns1__executeCommandResponse(), soap_out_SOAP_ENV__Code(), soap_out_SOAP_ENV__Detail(), soap_out_SOAP_ENV__Fault(), soap_out_SOAP_ENV__Header(), soap_out_SOAP_ENV__Reason(), soap_outbyte(), soap_outdateTime(), soap_outdouble(), soap_outfloat(), soap_outint(), soap_outliteral(), soap_outlong(), soap_outLONG64(), soap_outshort(), soap_outstring(), soap_outULONG64(), soap_outunsignedByte(), soap_outunsignedInt(), soap_outunsignedLong(), soap_outunsignedShort(), soap_outwliteral(), soap_outwstring(), and soap_send_fault().

◆ soap_element_href()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_href	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	ref,
		const char *	val
	)

Definition at line 13578 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element '%s' reference %s='%s'\n", tag, ref, val));
   if (soap_element(soap, tag, id, NULL)
    || soap_attribute(soap, ref, val)
    || soap_element_start_end_out(soap, tag))
     return soap->error;
   soap->body = 0;
   return SOAP_OK;
 }

References soap::body, DBGLOG, soap::error, NULL, soap_attribute(), soap_element(), soap_element_start_end_out(), SOAP_OK, and TEST().

Referenced by soap_attachment(), and soap_element_ref().

◆ soap_element_id()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_id	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const void *	p,
		const void *	a,
		int	n,
		const char *	type,
		int	t,
		char **	mark
	)

Definition at line 13647 of file stdsoap2.cpp.

 {
   (void)a; (void)n;
   if (!p)
   {
     soap->error = soap_element_null(soap, tag, id, type);
     return -1;
   }
 #ifndef WITH_NOIDREF
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element_id %p type=%d id=%d\n", p, t, id));
   if ((!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH)) || (soap->mode & SOAP_XML_TREE))
     return soap_check_and_mark(soap, p, t, mark);
   if (mark)
     *mark = NULL;
   if (id < -1)
     return soap_embed(soap, p, a, n, t);
   else if (id <= 0)
   {
     struct soap_plist *pp;
     if (a)
       id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
     else
       id = soap_pointer_lookup(soap, p, t, &pp);
     if (id)
     {
       if (soap_is_embedded(soap, pp))
       {
         soap_element_ref(soap, tag, 0, id);
         return -1;
       }
       if (soap_is_single(soap, pp))
         return 0;
       soap_set_embedded(soap, pp);
     }
   }
   return id;
 #else
   return soap_check_and_mark(soap, p, t, mark);
 #endif
 }

References mpq::a, DBGLOG, soap::encodingStyle, soap::error, soap_plist::id, soap::mode, NULL, soap_array_pointer_lookup(), soap_check_and_mark(), soap_element_null(), soap_element_ref(), soap_embed(), soap_is_embedded(), soap_is_single(), soap_pointer_lookup(), soap_set_embedded(), SOAP_XML_GRAPH, SOAP_XML_TREE, and TEST().

Referenced by soap_attachment(), soap_out_PointerToSOAP_ENV__Code(), soap_out_PointerToSOAP_ENV__Detail(), soap_out_PointerToSOAP_ENV__Reason(), soap_out_PointerTostring(), soap_outstring(), and soap_outwstring().

◆ soap_element_nil()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_nil	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13634 of file stdsoap2.cpp.

 {
   if (soap_element(soap, tag, -1, NULL)
    || (soap_attribute(soap, "xsi:nil", "true")))
     return soap->error;
   return soap_element_start_end_out(soap, tag);
 }

References soap::error, NULL, soap_attribute(), soap_element(), and soap_element_start_end_out().

◆ soap_element_null()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_null	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	type
	)

Definition at line 13594 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp = NULL;
   for (tp = soap->attributes; tp; tp = tp->next)
     if (tp->visible)
       break;
   if (tp || (soap->version == 2 && soap->position > 0) || id > 0 || (soap->mode & SOAP_XML_NIL))
   {
     if (soap_element(soap, tag, id, type)
      || (!tp && soap_attribute(soap, "xsi:nil", "true"))
      || soap_element_start_end_out(soap, tag))
       return soap->error;
     soap->body = 0;
   }
   else
   {
     soap->null = 1;
     soap->position = 0;
     soap->mustUnderstand = 0;
   }
   return SOAP_OK;
 }

References soap::attributes, soap::body, soap::error, soap::mode, soap::mustUnderstand, soap_attribute::next, soap::null, NULL, soap::position, soap_attribute(), soap_element(), soap_element_start_end_out(), SOAP_OK, SOAP_XML_NIL, soap::version, and soap_attribute::visible.

Referenced by soap_element_id(), soap_outstring(), and soap_outwstring().

◆ soap_element_ref()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_ref	(	struct soap *	soap,
		const char *	tag,
		int	id,
		int	href
	)

Definition at line 13556 of file stdsoap2.cpp.

 {
   const char *s = "ref";
   int n = 1;
   if (soap->version == 1)
   {
     s = "href";
     n = 0;
   }
   else if (soap->version == 2)
   {
     s = "SOAP-ENC:ref";
   }
   (SOAP_SNPRINTF(soap->href, sizeof(soap->href), sizeof(SOAP_BASEREFNAME) + 21), "#" SOAP_BASEREFNAME "%d", href);
   return soap_element_href(soap, tag, id, s, soap->href + n);
 }

References soap::href, SOAP_BASEREFNAME, soap_element_href(), SOAP_SNPRINTF, and soap::version.

Referenced by soap_element_id().

◆ soap_element_result()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_result	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13795 of file stdsoap2.cpp.

 {
   if (soap->version == 2 && soap->encodingStyle)
   {
     if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
      || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc)
      || soap_element_start_end_out(soap, NULL)
      || soap_string_out(soap, tag, 0)
      || soap_element_end_out(soap, "SOAP-RPC:result"))
       return soap->error;
   }
   return SOAP_OK;
 }

References soap::encodingStyle, soap::error, NULL, soap_attribute(), soap_element(), soap_element_end_out(), soap_element_start_end_out(), SOAP_OK, soap_rpc, soap_string_out(), and soap::version.

◆ soap_element_start_end_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_element_start_end_out	(	struct soap *	soap,
		const char *	tag
	)

Definition at line 13384 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp;
 #ifndef WITH_LEAN
   if ((soap->mode & SOAP_XML_CANONICAL))
   {
     struct soap_nlist *np;
     for (tp = soap->attributes; tp; tp = tp->next)
     {
       if (tp->visible && *tp->name && strchr(tp->name, ':'))
         soap_utilize_ns(soap, tp->name, 0);
     }
     if (soap->event == SOAP_SEC_BEGIN)
     {
       for (np = soap->nlist; np; np = np->next)
         if (soap_tagsearch(soap->c14ninclude, np->id))
           (void)soap_push_ns(soap, np->id, np->ns, 1, 0);
       soap->event = 0;
       soap->evlev = 0;
     }
     for (np = soap->nlist; np; np = np->next)
     {
       if (np->ns && np->index == 1)
       {
         if (*np->id)
           (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), strlen(np->id) + 6), "xmlns:%s", np->id);
         else
           soap_strcpy(soap->tmpbuf, sizeof(soap->tmpbuf), "xmlns");
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enabling utilized binding (level=%u) %s='%s' SEC-BEGIN=%d c14ninclude='%s'\n", np->level, soap->tmpbuf, np->ns, soap->event == SOAP_SEC_BEGIN, soap->c14ninclude ? soap->c14ninclude : "(null)"));
         np->index = 2;
         soap->level--;
         if (*np->id || *np->ns || soap->level > 1)
           if (soap_set_attr(soap, soap->tmpbuf, np->ns, 1))
             return soap->error;
         soap->level++;
       }
       else
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Binding (level=%u) %s='%s' utilized=%d\n", np->level, np->id, np->ns, np->index));
       }
     }
   }
 #endif
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     struct soap_dom_attribute **att;
     att = &soap->dom->atts;
     for (tp = soap->attributes; tp; tp = tp->next)
     {
       if (tp->visible)
       {
         *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
         if (!*att)
           return soap->error;
         (*att)->next = NULL;
         (*att)->nstr = NULL;
         (*att)->name = soap_strdup(soap, tp->name);
         (*att)->text = soap_strdup(soap, tp->value);
         (*att)->soap = soap;
         if (!(*att)->name || (tp->value && !(*att)->text))
           return soap->error = SOAP_EOM;
         att = &(*att)->next;
         tp->visible = 0;
       }
     }
     return SOAP_OK;
   }
 #endif
   for (tp = soap->attributes; tp; tp = tp->next)
   {
     if (tp->visible)
     {
       if (soap_send_raw(soap, " ", 1) || soap_send(soap, tp->name))
         return soap->error;
       if (tp->visible == 2 && tp->value)
       {
         if (soap_send_raw(soap, "=\"", 2)
          || soap_string_out(soap, tp->value, tp->flag)
          || soap_send_raw(soap, "\"", 1))
           return soap->error;
       }
       else
       {
         if (soap_send_raw(soap, "=\"\"", 3))
           return soap->error;
       }
       tp->visible = 0;
     }
   }
   if (tag)
   {
 #ifndef WITH_LEAN
     if ((soap->mode & SOAP_XML_CANONICAL))
     {
       if (soap_send_raw(soap, ">", 1)
        || soap_element_end_out(soap, tag))
         return soap->error;
       return SOAP_OK;
     }
 #endif
     if (soap->nlist)
       soap_pop_namespace(soap);
     soap->level--;      /* decrement level just before /> */
     soap->body = 0;
     return soap_send_raw(soap, "/>", 2);
   }
   return soap_send_raw(soap, ">", 1);
 }

References soap::attributes, soap_dom_element::atts, soap::body, soap::c14ninclude, DBGLOG, soap::dom, soap::error, soap::event, soap::evlev, soap_attribute::flag, soap_nlist::id, soap_nlist::index, soap_nlist::level, soap::level, soap::mode, soap_attribute::name, soap_nlist::next, soap_attribute::next, soap_dom_attribute::next, soap::nlist, soap_nlist::ns, NULL, soap, soap_element_end_out(), SOAP_EOM, soap_malloc(), SOAP_OK, soap_pop_namespace(), soap_push_ns(), SOAP_SEC_BEGIN, soap_send(), soap_send_raw(), soap_set_attr(), SOAP_SNPRINTF, soap_strcpy, soap_strdup(), soap_string_out(), soap_tagsearch(), soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_DOM, TEST(), soap::tmpbuf, soap_attribute::value, and soap_attribute::visible.

Referenced by soap_array_begin_out(), soap_element_begin_out(), soap_element_empty(), soap_element_href(), soap_element_nil(), soap_element_null(), and soap_element_result().

◆ soap_elt()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag
	)

◆ soap_elt_bool()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_bool	(	struct soap_dom_element *	elt,
		LONG64	b
	)

◆ soap_elt_copy()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_copy	(	struct soap_dom_element *	elt,
		const struct soap_dom_element *	node
	)

◆ soap_elt_depth()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_depth ( const struct soap_dom_element * elt )

◆ soap_elt_double()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_double	(	struct soap_dom_element *	elt,
		double	x
	)

◆ soap_elt_find()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_find	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_elt_find_next()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_find_next	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_elt_find_next_type()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_find_next_type	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt,
		int	type
	)

◆ soap_elt_find_type()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_find_type	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt,
		int	type
	)

◆ soap_elt_first()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_first ( struct soap_dom_element * elt )

◆ soap_elt_get()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_get	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag
	)

◆ soap_elt_get_double()

SOAP_FMAC1 double SOAP_FMAC2 soap_elt_get_double ( const struct soap_dom_element * elt )

◆ soap_elt_get_int()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_get_int ( const struct soap_dom_element * elt )

◆ soap_elt_get_long()

SOAP_FMAC1 long SOAP_FMAC2 soap_elt_get_long ( const struct soap_dom_element * elt )

◆ soap_elt_get_LONG64()

SOAP_FMAC1 LONG64 SOAP_FMAC2 soap_elt_get_LONG64 ( const struct soap_dom_element * elt )

◆ soap_elt_get_next()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_get_next ( const struct soap_dom_element * elt )

◆ soap_elt_get_node()

SOAP_FMAC1 const void* SOAP_FMAC2 soap_elt_get_node	(	const struct soap_dom_element *	elt,
		int	type
	)

◆ soap_elt_get_ns()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_elt_get_ns ( const struct soap_dom_element * elt )

◆ soap_elt_get_nth()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_get_nth	(	struct soap_dom_element *	elt,
		size_t	n
	)

◆ soap_elt_get_tag()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_elt_get_tag ( const struct soap_dom_element * elt )

◆ soap_elt_get_text()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_elt_get_text ( const struct soap_dom_element * elt )

◆ soap_elt_get_type()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_get_type	(	const struct soap_dom_element *	elt,
		const void **	node
	)

◆ soap_elt_get_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_get_w	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_elt_index()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_index ( const struct soap_dom_element * elt )

◆ soap_elt_int()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_int	(	struct soap_dom_element *	elt,
		LONG64	n
	)

◆ soap_elt_is_false()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_is_false ( const struct soap_dom_element * elt )

◆ soap_elt_is_true()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_is_true ( const struct soap_dom_element * elt )

◆ soap_elt_len()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_len ( const struct soap_dom_element * elt )

◆ soap_elt_match()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_match	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_elt_match_w()

SOAP_FMAC1 int SOAP_FMAC2 soap_elt_match_w	(	const struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	patt
	)

◆ soap_elt_new()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_new	(	struct soap *	soap,
		const char *	ns,
		const char *	tag
	)

◆ soap_elt_new_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_new_w	(	struct soap *	soap,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_elt_next()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_next ( const struct soap_dom_element * elt )

◆ soap_elt_node()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_node	(	struct soap_dom_element *	elt,
		const void *	node,
		int	type
	)

◆ soap_elt_nth()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_nth ( const struct soap_dom_element * elt )

◆ soap_elt_parent()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_parent ( const struct soap_dom_element * elt )

◆ soap_elt_set()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_set	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag
	)

◆ soap_elt_set_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_set_w	(	struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_elt_size()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_size	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt
	)

◆ soap_elt_size_type()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_elt_size_type	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	patt,
		int	type
	)

◆ soap_elt_text()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_text	(	struct soap_dom_element *	elt,
		const char *	text
	)

◆ soap_elt_text_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_text_w	(	struct soap_dom_element *	elt,
		const wchar_t *	text
	)

◆ soap_elt_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_elt_w	(	struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag
	)

◆ soap_embed()

SOAP_FMAC1 int SOAP_FMAC2 soap_embed	(	struct soap *	soap,
		const void *	p,
		const void *	a,
		int	n,
		int	t
	)

Definition at line 9627 of file stdsoap2.cpp.

 {
   int id;
   struct soap_plist *pp;
   if (soap->version == 2)
     soap->encoding = 1;
   if (!p || (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH)) || (soap->mode & SOAP_XML_TREE))
     return 0;
   if (a)
     id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
   else
     id = soap_pointer_lookup(soap, p, t, &pp);
   if (id)
   {
     if (soap_is_embedded(soap, pp) || soap_is_single(soap, pp))
       return 0;
     soap_set_embedded(soap, pp);
   }
   return id;
 }

References mpq::a, soap::encoding, soap::encodingStyle, soap_plist::id, soap::mode, soap_array_pointer_lookup(), soap_is_embedded(), soap_is_single(), soap_pointer_lookup(), soap_set_embedded(), SOAP_XML_GRAPH, SOAP_XML_TREE, and soap::version.

Referenced by soap_element_id(), and soap_embedded_id().

◆ soap_embedded()

SOAP_FMAC1 void SOAP_FMAC2 soap_embedded	(	struct soap *	soap,
		const void *	p,
		int	t
	)

Definition at line 10013 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   if (soap_pointer_lookup(soap, p, t, &pp))
   {
     pp->mark1 = 1;
     pp->mark2 = 1;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded %p type=%d mark set to 1\n", p, t));
   }
 }

References DBGLOG, soap_plist::mark1, soap_plist::mark2, soap_pointer_lookup(), and TEST().

◆ soap_embedded_id()

SOAP_FMAC1 int SOAP_FMAC2 soap_embedded_id	(	struct soap *	soap,
		int	id,
		const void *	p,
		int	t
	)

Definition at line 10117 of file stdsoap2.cpp.

 {
   struct soap_plist *pp = NULL;
   if (id >= 0 || (!soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH)) || (soap->omode & SOAP_XML_TREE))
     return id;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id));
   if (id < -1)
     return soap_embed(soap, p, NULL, 0, t);
   if (id < 0)
   {
     id = soap_pointer_lookup(soap, p, t, &pp);
     if (soap->version == 1 && soap->part != SOAP_IN_HEADER)
     {
       if (id)
       {
         if ((soap->mode & SOAP_IO_LENGTH))
           pp->mark1 = 2;
         else
           pp->mark2 = 2;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id multiref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2));
       }
       return -1;
     }
     else if (id)
     {
       if ((soap->mode & SOAP_IO_LENGTH))
         pp->mark1 = 1;
       else
         pp->mark2 = 1;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id embedded ref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2));
     }
   }
   return id;
 }

References DBGLOG, soap::encodingStyle, soap_plist::id, soap_plist::mark1, soap_plist::mark2, soap::mode, NULL, soap::omode, soap::part, soap_embed(), SOAP_IN_HEADER, SOAP_IO_LENGTH, soap_pointer_lookup(), SOAP_XML_GRAPH, SOAP_XML_TREE, TEST(), and soap::version.

Referenced by soap_out_ns1__executeCommand(), soap_out_ns1__executeCommandResponse(), soap_out_SOAP_ENV__Code(), soap_out_SOAP_ENV__Detail(), soap_out_SOAP_ENV__Fault(), soap_out_SOAP_ENV__Header(), soap_out_SOAP_ENV__Reason(), soap_outbyte(), soap_outdateTime(), soap_outdouble(), soap_outfloat(), soap_outint(), soap_outlong(), soap_outLONG64(), soap_outshort(), soap_outULONG64(), soap_outunsignedByte(), soap_outunsignedInt(), soap_outunsignedLong(), and soap_outunsignedShort().

◆ soap_encode_url()

SOAP_FMAC1 int SOAP_FMAC2 soap_encode_url	(	const char *	s,
		char *	t,
		int	len
	)

Definition at line 8513 of file stdsoap2.cpp.

 {
   int c;
   int n = len;
   if (s && n > 0)
   {
     while ((c = *s++) && --n > 0)
     {
       if (c == '-'
        || c == '.'
        || (c >= '0' && c <= '9')
        || (c >= 'A' && c <= 'Z')
        || c == '_'
        || (c >= 'a' && c <= 'z')
        || c == '~')
       {
         *t++ = c;
       }
       else if (n > 2)
       {
         *t++ = '%';
         *t++ = (c >> 4) + (c > 159 ? '7' : '0');
         c &= 0xF;
         *t++ = c + (c > 9 ? '7' : '0');
         n -= 2;
       }
       else
       {
         break;
       }
     }
     *t = '\0';
   }
   return len - n;
 }

References mpq::c.

Referenced by soap_encode_url_string(), soap_query_send_key(), soap_query_send_val(), and soap_url_query().

◆ soap_encode_url_string()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_encode_url_string	(	struct soap *	soap,
		const char *	s
	)

Definition at line 8554 of file stdsoap2.cpp.

 {
   if (s)
   {
     int n = 3 * (int)strlen(s) + 1;
     char *t = (char*)soap_malloc(soap, n);
     if (t)
     {
       (void)soap_encode_url(s, t, n);
       return t;
     }
   }
   return SOAP_STR_EOS;
 }

References soap_encode_url(), soap_malloc(), and SOAP_STR_EOS.

◆ soap_end()

SOAP_FMAC1 void SOAP_FMAC2 soap_end ( struct soap * soap )

Definition at line 12427 of file stdsoap2.cpp.

 {
   if (soap_check_state(soap))
     return;
   soap_free_temp(soap);
   soap_dealloc(soap, NULL);
   while (soap->clist)
   {
     struct soap_clist *cp = soap->clist->next;
     SOAP_FREE(soap, soap->clist);
     soap->clist = cp;
   }
   soap_closesock(soap);
 #ifdef SOAP_DEBUG
   soap_close_logfiles(soap);
 #endif
 }

References soap::clist, soap_clist::next, NULL, soap_check_state, soap_close_logfiles(), soap_closesock(), soap_dealloc(), SOAP_FREE, and soap_free_temp().

Referenced by ACSoapThread(), process_message(), soap_copy_context(), and soap_serve().

◆ soap_end_block()

SOAP_FMAC1 void SOAP_FMAC2 soap_end_block	(	struct soap *	soap,
		struct soap_blist *	b
	)

Definition at line 3295 of file stdsoap2.cpp.

 {
   struct soap_bhead *p, *q;
   if (!b)
     b = soap->blist;
   if (b)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of block sequence, free all remaining blocks\n"));
     for (p = b->head; p; p = q)
     {
       q = p->next;
       SOAP_FREE(soap, p);
     }
     if (soap->blist == b)
       soap->blist = b->next;
     else
     {
       struct soap_blist *bp;
       for (bp = soap->blist; bp; bp = bp->next)
       {
         if (bp->next == b)
         {
           bp->next = b->next;
           break;
         }
       }
     }
     SOAP_FREE(soap, b);
   }
   DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug, "Restored previous block sequence\n"));
 #ifndef WITH_NOIDREF
   if (!soap->blist && ((soap->version && !(soap->imode & SOAP_XML_TREE)) || (soap->mode & SOAP_XML_GRAPH)))
   {
     int i;
     struct soap_ilist *ip = NULL;
     for (i = 0; i < SOAP_IDHASH; i++)
       for (ip = soap->iht[i]; ip; ip = ip->next)
         ip->shaky = 0;
   }
 #endif
 }

References b, soap::blist, DBGLOG, soap::iht, soap::imode, soap::mode, soap_bhead::next, soap_blist::next, soap_ilist::next, NULL, soap_ilist::shaky, SOAP_FREE, SOAP_IDHASH, SOAP_XML_GRAPH, SOAP_XML_TREE, TEST(), and soap::version.

Referenced by soap_end_send_flush(), soap_free_temp(), soap_gethex(), and soap_save_block().

◆ soap_end_count()

SOAP_FMAC1 int SOAP_FMAC2 soap_end_count ( struct soap * soap )

Definition at line 9824 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of count phase\n"));
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_IO_LENGTH))
   {
     if (soap_end_attachments(soap))
       return soap->error;
     if (soap->fpreparefinalsend && (soap->error = soap->fpreparefinalsend(soap)) != SOAP_OK)
       return soap->error;
   }
 #else
   (void)soap;
 #endif
   return SOAP_OK;
 }

References DBGLOG, soap::error, soap::fpreparefinalsend, soap::mode, soap_end_attachments(), SOAP_IO_LENGTH, SOAP_OK, and TEST().

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_end_recv()

SOAP_FMAC1 int SOAP_FMAC2 soap_end_recv ( struct soap * soap )

Definition at line 11393 of file stdsoap2.cpp.

 {
   soap->part = SOAP_END;
 #ifndef WITH_LEAN
   soap->wsuid = NULL;           /* reset before next send */
   soap->c14nexclude = NULL;     /* reset before next send */
   soap->c14ninclude = NULL;     /* reset before next send */
 #endif
 #ifndef WITH_LEANER
   soap->ffilterrecv = NULL;
   if ((soap->mode & SOAP_ENC_DIME) && soap_getdime(soap))
   {
     soap->dime.first = NULL;
     soap->dime.last = NULL;
     return soap->error;
   }
   soap->dime.list = soap->dime.first;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
   /* Check if MIME attachments and mime-post-check flag is set, if so call soap_resolve() and return */
   if ((soap->mode & SOAP_ENC_MIME))
   {
     if ((soap->mode & SOAP_MIME_POSTCHECK))
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Post checking MIME attachments\n"));
       if (!soap->keep_alive)
         soap->keep_alive = -2; /* special case to keep alive */
 #ifndef WITH_NOIDREF
       soap_resolve(soap);
 #endif
       return SOAP_OK;
     }
     if (soap_getmime(soap))
       return soap->error;
   }
   soap->mime.list = soap->mime.first;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->mime.boundary = NULL;
   if (soap->xlist)
   {
     struct soap_multipart *content;
     for (content = soap->mime.list; content; content = content->next)
       soap_resolve_attachment(soap, content);
   }
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of receive message ok\n"));
 #ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && soap->d_stream)
   {
     /* Make sure end of compressed content is reached */
     while (soap->d_stream->next_out != Z_NULL)
       if ((int)soap_get1(soap) == EOF)
         break;
     soap->mode &= ~SOAP_ENC_ZLIB;
     (void)soap_memcpy((void*)soap->buf, sizeof(soap->buf), (const void*)soap->z_buf, sizeof(soap->buf));
     soap->bufidx = (char*)soap->d_stream->next_in - soap->z_buf;
     soap->buflen = soap->z_buflen;
     soap->zlib_state = SOAP_ZLIB_NONE;
     if (inflateEnd(soap->d_stream) != Z_OK)
       return soap->error = SOAP_ZLIB_ERROR;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate end ok\n"));
 #ifdef WITH_GZIP
     if (soap->zlib_in == SOAP_ZLIB_GZIP)
     {
       soap_wchar c;
       short i;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate gzip crc check\n"));
       for (i = 0; i < 8; i++)
       {
         if ((int)(c = soap_get1(soap)) == EOF)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Gzip error: unable to read crc value\n"));
           return soap->error = SOAP_ZLIB_ERROR;
         }
         soap->z_buf[i] = (char)c;
       }
       if (soap->z_crc != ((uLong)(unsigned char)soap->z_buf[0] | ((uLong)(unsigned char)soap->z_buf[1] << 8) | ((uLong)(unsigned char)soap->z_buf[2] << 16) | ((uLong)(unsigned char)soap->z_buf[3] << 24)))
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Gzip inflate error: crc check failed, message corrupted? (crc32=%lu)\n", (unsigned long)soap->z_crc));
         return soap->error = SOAP_ZLIB_ERROR;
       }
       if (soap->d_stream->total_out != ((uLong)(unsigned char)soap->z_buf[4] | ((uLong)(unsigned char)soap->z_buf[5] << 8) | ((uLong)(unsigned char)soap->z_buf[6] << 16) | ((uLong)(unsigned char)soap->z_buf[7] << 24)))
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Gzip inflate error: incorrect message length\n"));
         return soap->error = SOAP_ZLIB_ERROR;
       }
     }
     soap->zlib_in = SOAP_ZLIB_NONE;
 #endif
   }
 #endif
   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
     while ((int)soap->ahead != EOF && !soap_recv_raw(soap))
       continue;
 #ifndef WITH_NOIDREF
   if (soap_resolve(soap))
     return soap->error;
 #endif
 #ifndef WITH_LEANER
   if (soap->xlist)
   {
     if ((soap->mode & SOAP_ENC_MTOM))
       return soap->error = SOAP_MIME_HREF;
     return soap->error = SOAP_DIME_HREF;
   }
 #endif
   soap_free_ns(soap);
 #ifndef WITH_LEANER
   if (soap->fpreparefinalrecv)
     return soap->error = soap->fpreparefinalrecv(soap);
 #endif
   return SOAP_OK;
 }

References soap::ahead, soap_mime::boundary, soap::buf, soap::bufidx, soap::buflen, mpq::c, soap::c14nexclude, soap::c14ninclude, soap::d_stream, DBGLOG, soap::dime, soap::error, soap::ffilterrecv, soap_dime::first, soap_mime::first, soap::fpreparefinalrecv, if(), inflateEnd(), soap::keep_alive, soap_dime::last, soap_mime::last, soap_dime::list, soap_mime::list, soap::mime, soap::mode, soap_multipart::next, NULL, soap::part, SOAP_DIME_HREF, SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_MTOM, SOAP_ENC_ZLIB, SOAP_END, soap_free_ns(), soap_get1, soap_getdime(), soap_getmime(), SOAP_IO, SOAP_IO_CHUNK, soap_memcpy, SOAP_MIME_HREF, SOAP_MIME_POSTCHECK, SOAP_OK, soap_recv_raw(), soap_resolve(), soap_resolve_attachment(), SOAP_ZLIB_ERROR, SOAP_ZLIB_GZIP, SOAP_ZLIB_NONE, TEST(), soap::wsuid, soap::xlist, soap::z_buf, soap::z_buflen, soap::z_crc, Z_NULL, Z_OK, soap::zlib_in, and soap::zlib_state.

Referenced by soap_begin_recv(), soap_read__QName(), soap_read_byte(), soap_read_int(), soap_read_ns1__executeCommand(), soap_read_ns1__executeCommandResponse(), soap_read_SOAP_ENV__Code(), soap_read_SOAP_ENV__Detail(), soap_read_SOAP_ENV__Fault(), soap_read_SOAP_ENV__Header(), soap_read_SOAP_ENV__Reason(), soap_read_string(), soap_recv_empty_response(), soap_recv_fault(), soap_recv_mime_attachment(), and soap_serve_ns1__executeCommand().

◆ soap_end_send()

SOAP_FMAC1 int SOAP_FMAC2 soap_end_send ( struct soap * soap )

Definition at line 11209 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEANER
   int err;
   err = soap_end_attachments(soap);
   if (soap->dime.list)
   {
     /* SOAP body referenced attachments must appear first */
     soap->dime.last->next = soap->dime.first;
     soap->dime.first = soap->dime.list->next;
     soap->dime.list->next = NULL;
     soap->dime.last = soap->dime.list;
   }
   if (!err)
     err = soap_putdime(soap);
   if (!err)
     err = soap_putmime(soap);
   soap->mime.list = NULL;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->dime.list = NULL;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
   if (err)
     return err;
 #endif
   return soap_end_send_flush(soap);
 }

References soap::dime, soap_dime::first, soap_mime::first, soap_dime::last, soap_mime::last, soap_dime::list, soap_mime::list, soap::mime, soap_multipart::next, NULL, soap_end_attachments(), soap_end_send_flush(), soap_putdime(), and soap_putmime().

Referenced by soap_PATCH__QName(), soap_PATCH_byte(), soap_PATCH_int(), soap_PATCH_ns1__executeCommand(), soap_PATCH_ns1__executeCommandResponse(), soap_PATCH_SOAP_ENV__Code(), soap_PATCH_SOAP_ENV__Detail(), soap_PATCH_SOAP_ENV__Fault(), soap_PATCH_SOAP_ENV__Header(), soap_PATCH_SOAP_ENV__Reason(), soap_PATCH_string(), soap_POST_send__QName(), soap_POST_send_byte(), soap_POST_send_int(), soap_POST_send_ns1__executeCommand(), soap_POST_send_ns1__executeCommandResponse(), soap_POST_send_SOAP_ENV__Code(), soap_POST_send_SOAP_ENV__Detail(), soap_POST_send_SOAP_ENV__Fault(), soap_POST_send_SOAP_ENV__Header(), soap_POST_send_SOAP_ENV__Reason(), soap_POST_send_string(), soap_PUT__QName(), soap_PUT_byte(), soap_PUT_int(), soap_PUT_ns1__executeCommand(), soap_PUT_ns1__executeCommandResponse(), soap_PUT_SOAP_ENV__Code(), soap_PUT_SOAP_ENV__Detail(), soap_PUT_SOAP_ENV__Fault(), soap_PUT_SOAP_ENV__Header(), soap_PUT_SOAP_ENV__Reason(), soap_PUT_string(), soap_send_empty_response(), soap_send_fault(), soap_serve_ns1__executeCommand(), soap_write__QName(), soap_write_byte(), soap_write_int(), soap_write_ns1__executeCommand(), soap_write_ns1__executeCommandResponse(), soap_write_SOAP_ENV__Code(), soap_write_SOAP_ENV__Detail(), soap_write_SOAP_ENV__Fault(), soap_write_SOAP_ENV__Header(), soap_write_SOAP_ENV__Reason(), and soap_write_string().

◆ soap_end_send_flush()

SOAP_FMAC1 int SOAP_FMAC2 soap_end_send_flush ( struct soap * soap )

Definition at line 11243 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End send mode=0x%x\n", soap->mode));
   if ((soap->mode & SOAP_IO)) /* need to flush the remaining data in buffer */
   {
     if (soap_flush(soap))
 #ifdef WITH_ZLIB
     {
       if ((soap->mode & SOAP_ENC_ZLIB) && soap->zlib_state == SOAP_ZLIB_DEFLATE)
       {
         soap->zlib_state = SOAP_ZLIB_NONE;
         deflateEnd(soap->d_stream);
       }
       return soap->error;
     }
 #else
       return soap->error;
 #endif
 #ifdef WITH_ZLIB
     if ((soap->mode & SOAP_ENC_ZLIB) && soap->d_stream)
     {
       int r;
       soap->d_stream->avail_in = 0;
       do
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating remainder\n"));
         r = deflate(soap->d_stream, Z_FINISH);
         if (soap->d_stream->avail_out != sizeof(soap->buf))
         {
           if (soap_flush_raw(soap, soap->z_buf, sizeof(soap->buf) - soap->d_stream->avail_out))
           {
             soap->zlib_state = SOAP_ZLIB_NONE;
             deflateEnd(soap->d_stream);
             return soap->error;
           }
           soap->d_stream->next_out = (Byte*)soap->z_buf;
           soap->d_stream->avail_out = sizeof(soap->buf);
         }
       } while (r == Z_OK);
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
       soap->z_ratio_out = (float)soap->d_stream->total_out / (float)soap->d_stream->total_in;
       soap->mode &= ~SOAP_ENC_ZLIB;
       soap->zlib_state = SOAP_ZLIB_NONE;
       if (deflateEnd(soap->d_stream) != Z_OK || r != Z_STREAM_END)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
         return soap->error = SOAP_ZLIB_ERROR;
       }
 #ifdef WITH_GZIP
       if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
       {
         soap->z_buf[0] = soap->z_crc & 0xFF;
         soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF;
         soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF;
         soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF;
         soap->z_buf[4] = soap->d_stream->total_in & 0xFF;
         soap->z_buf[5] = (soap->d_stream->total_in >> 8) & 0xFF;
         soap->z_buf[6] = (soap->d_stream->total_in >> 16) & 0xFF;
         soap->z_buf[7] = (soap->d_stream->total_in >> 24) & 0xFF;
         if (soap_flush_raw(soap, soap->z_buf, 8))
           return soap->error;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc));
       }
 #endif
     }
 #endif
     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
     {
 #if !defined(__cplusplus) || defined(WITH_COMPAT)
       if (soap->os)
       {
         char *b = (char*)soap_push_block(soap, NULL, 1);
         if (b)
         {
           *b = '\0';
           *soap->os = soap_save_block(soap, NULL, NULL, 0);
         }
       }
       else
 #endif
       {
         char *p;
 #ifndef WITH_NOHTTP
         if (!(soap->mode & SOAP_ENC_PLAIN))
         {
           soap->mode--;
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending buffered message of length %u\n", (unsigned int)soap->blist->size));
           if (soap->status >= SOAP_POST)
             soap->error = soap->fpost(soap, soap->endpoint, soap->host, soap->port, soap->path, soap->action, soap->blist->size);
           else if (soap->status != SOAP_STOP)
             soap->error = soap->fresponse(soap, soap->status, soap->blist->size);
           if (soap->error || soap_flush(soap))
             return soap->error;
           soap->mode++;
         }
 #endif
         for (p = soap_first_block(soap, NULL); p; p = soap_next_block(soap, NULL))
         {
           DBGMSG(SENT, p, soap_block_size(soap, NULL));
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send %u bytes to socket=%d/fd=%d\n", (unsigned int)soap_block_size(soap, NULL), (int)soap->socket, soap->sendfd));
           soap->error = soap->fsend(soap, p, soap_block_size(soap, NULL));
           if (soap->error)
           {
             soap_end_block(soap, NULL);
             return soap->error;
           }
         }
         soap_end_block(soap, NULL);
       }
 #ifndef WITH_LEANER
       if (soap->fpreparefinalsend && (soap->error = soap->fpreparefinalsend(soap)) != SOAP_OK)
         return soap->error;
 #endif
       if ((soap->omode & SOAP_IO) == SOAP_IO_STORE && (soap->imode & SOAP_IO) != SOAP_IO_STORE)
         soap->omode = (soap->omode & ~SOAP_IO) | (soap->imode & SOAP_IO);
     }
 #ifndef WITH_LEANER
     else if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
     {
       DBGMSG(SENT, "\r\n0\r\n\r\n", 7);
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send 7 bytes to socket=%d/fd=%d\n", (int)soap->socket, soap->sendfd));
       soap->error = soap->fsend(soap, "\r\n0\r\n\r\n", 7);
       if (soap->error)
         return soap->error;
     }
 #endif
   }
 #ifdef WITH_TCPFIN
 #if defined(WITH_OPENSSL) || defined(WITH_SYSTEMSSL)
   if (!soap->ssl)
 #endif
     if (soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
       soap->fshutdownsocket(soap, soap->socket, SOAP_SHUT_WR); /* Send TCP FIN */
 #endif
 #if defined(__cplusplus) && !defined(WITH_COMPAT)
   if (soap->os)
     soap->os->flush();
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send phase\n"));
   soap->omode &= ~SOAP_SEC_WSUID;
   soap->count = 0;
   soap->part = SOAP_END;
   return SOAP_OK;
 }

References soap::action, b, soap::blist, soap::buf, soap::count, soap::d_stream, DBGLOG, DBGMSG, deflate(), deflateEnd(), soap::endpoint, soap::error, soap::fpost, soap::fpreparefinalsend, soap::fresponse, soap::fsend, soap::fshutdownsocket, soap::host, soap::imode, soap::keep_alive, soap::mode, NULL, soap::omode, soap::os, soap::part, soap::path, soap::port, soap::sendfd, soap_blist::size, soap_block_size(), SOAP_ENC_PLAIN, SOAP_ENC_ZLIB, SOAP_END, soap_end_block(), soap_first_block(), soap_flush(), soap_flush_raw(), SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, SOAP_IO_UDP, soap_next_block(), SOAP_OK, SOAP_POST, soap_push_block(), soap_save_block(), SOAP_SEC_WSUID, SOAP_SHUT_WR, SOAP_STOP, SOAP_STR_EOS, soap_valid_socket, SOAP_ZLIB_DEFLATE, SOAP_ZLIB_ERROR, SOAP_ZLIB_NONE, soap::socket, soap::ssl, soap::status, TEST(), soap::z_buf, soap::z_crc, Z_FINISH, Z_OK, soap::z_ratio_out, Z_STREAM_END, soap::zlib_out, and soap::zlib_state.

Referenced by soap_end_send(), soap_try_connect_command(), and tcp_connect().

◆ soap_end_shaky()

SOAP_FMAC1 void SOAP_FMAC2 soap_end_shaky	(	struct soap *	soap,
		short	f
	)

Definition at line 10876 of file stdsoap2.cpp.

 {
   soap->shaky = f;
 }

References f(), and soap::shaky.

◆ soap_enter()

SOAP_FMAC1 struct soap_ilist* SOAP_FMAC2 soap_enter	(	struct soap *	soap,
		const char *	id,
		int	t,
		size_t	n
	)

Definition at line 10369 of file stdsoap2.cpp.

 {
   size_t h;
   struct soap_ilist *ip = NULL;
   size_t l = strlen(id);
   if (sizeof(struct soap_ilist) + l > l && (SOAP_MAXALLOCSIZE <= 0 || sizeof(struct soap_ilist) + l <= SOAP_MAXALLOCSIZE))
     ip = (struct soap_ilist*)SOAP_MALLOC(soap, sizeof(struct soap_ilist) + l);
   if (ip)
   {
     ip->type = t;
     ip->size = n;
     ip->ptr = NULL;
     ip->spine = NULL;
     ip->link = NULL;
     ip->copy = NULL;
     ip->flist = NULL;
     ip->smart = NULL;
     ip->shaky = 0;
     (void)soap_memcpy((char*)ip->id, l + 1, id, l + 1);
     h = soap_hash(id); /* h = (HASH(id) % SOAP_IDHASH) so soap->iht[h] is safe */
     ip->next = soap->iht[h];
     soap->iht[h] = ip;
   }
   return ip;
 }

References soap_ilist::copy, soap_ilist::flist, soap_ilist::id, soap::iht, mpq::l, soap_ilist::link, soap_ilist::next, NULL, soap_ilist::ptr, soap_ilist::shaky, soap_ilist::size, soap_ilist::smart, soap_hash(), SOAP_MALLOC, SOAP_MAXALLOCSIZE, soap_memcpy, soap_ilist::spine, and soap_ilist::type.

Referenced by soap_id_enter(), soap_id_forward(), soap_id_lookup(), and soap_id_smart().

◆ soap_envelope_begin_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_begin_in ( struct soap * soap )

Definition at line 21015 of file stdsoap2.cpp.

 {
   soap->part = SOAP_IN_ENVELOPE;
   if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL))
   {
     if (soap->error == SOAP_TAG_MISMATCH)
     {
       if (!soap_element_begin_in(soap, "Envelope", 0, NULL))
         soap->error = SOAP_VERSIONMISMATCH;
       else if (soap->status == 0
            || (soap->status >= 200 && soap->status <= 299)
            || soap->status == 400
            || soap->status == 500)
         return SOAP_OK; /* allow non-SOAP (REST) XML content to be captured */
       soap->error = soap->status;
     }
     else if (soap->status)
     {
       soap->error = soap->status;
     }
     return soap->error;
   }
   soap_version(soap);
   return SOAP_OK;
 }

References soap::error, NULL, soap::part, soap_element_begin_in(), SOAP_IN_ENVELOPE, SOAP_OK, SOAP_TAG_MISMATCH, soap_version(), SOAP_VERSIONMISMATCH, and soap::status.

Referenced by soap_begin_serve().

◆ soap_envelope_begin_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_begin_out ( struct soap * soap )

Definition at line 20818 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   soap->part = SOAP_IN_ENVELOPE;
   return soap_element_begin_out(soap, "SOAP-ENV:Envelope", 0, NULL);
 }

References NULL, soap::part, soap_element_begin_out(), SOAP_IN_ENVELOPE, SOAP_OK, and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_envelope_end_in()

SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_end_in ( struct soap * soap )

Definition at line 21046 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   soap->part = SOAP_END_ENVELOPE;
   return soap_element_end_in(soap, "SOAP-ENV:Envelope");
 }

References soap::part, soap_element_end_in(), SOAP_END_ENVELOPE, SOAP_OK, and soap::version.

Referenced by soap_recv_fault(), and soap_serve_ns1__executeCommand().

◆ soap_envelope_end_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_end_out ( struct soap * soap )

Definition at line 20831 of file stdsoap2.cpp.

 {
   if (soap->version == 0)
     return SOAP_OK;
   if (soap_element_end_out(soap, "SOAP-ENV:Envelope")
    || soap_send_raw(soap, "\r\n", 2))   /* 2.8: always emit \r\n */
     return soap->error;
   soap->part = SOAP_END_ENVELOPE;
   return SOAP_OK;
 }

References soap::error, soap::part, soap_element_end_out(), SOAP_END_ENVELOPE, SOAP_OK, soap_send_raw(), and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_extend_url()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_extend_url	(	struct soap *	soap,
		const char *	s,
		const char *	t
	)

Definition at line 8425 of file stdsoap2.cpp.

 {
   if (s)
     soap_strcpy(soap->msgbuf, sizeof(soap->msgbuf), s);
   else
     *soap->msgbuf = '\0';
   if (t && (*t == '/' || *t == '?'))
   {
     char *r = strchr(soap->msgbuf, '?');
     if (r)
     {
       if (*t == '?')
       {
         soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), "&");
         soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), t + 1);
       }
       else /* *t == '/' */
       {
         size_t l = r - soap->msgbuf;
         *r = '\0';
         soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), t);
         if (s)
           soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), s + l);
       }
     }
     else
     {
       soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), t);
     }
   }
   return soap->msgbuf;
 }

References mpq::l, soap::msgbuf, soap_strcat(), and soap_strcpy.

Referenced by soap_extend_url_query().

◆ soap_extend_url_query()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_extend_url_query	(	struct soap *	soap,
		const char *	s,
		const char *	t
	)

Definition at line 8463 of file stdsoap2.cpp.

 {
   (void)soap_extend_url(soap, s, t); /* fills and returns soap->msgbuf */
   if (strchr(soap->msgbuf, '?'))
     soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), "&");
   else
     soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), "?");
   return soap->msgbuf;
 }

References soap::msgbuf, soap_extend_url(), and soap_strcat().

◆ soap_fault()

SOAP_FMAC3 void SOAP_FMAC4 soap_fault ( struct soap * soap )

Definition at line 59 of file soapC.cpp.

 {
     if (soap->fault == NULL)
     {   soap->fault = soap_new_SOAP_ENV__Fault(soap, -1);
         if (soap->fault == NULL)
             return;
     }
     if (soap->version == 2 && soap->fault->SOAP_ENV__Code == NULL)
         soap->fault->SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap, -1);
     if (soap->version == 2 && soap->fault->SOAP_ENV__Reason == NULL)
         soap->fault->SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap, -1);
 }

References soap::fault, NULL, SOAP_ENV__Fault::SOAP_ENV__Code, SOAP_ENV__Fault::SOAP_ENV__Reason, soap_new_SOAP_ENV__Code(), soap_new_SOAP_ENV__Fault(), soap_new_SOAP_ENV__Reason(), and soap::version.

Referenced by soap_faultcode(), soap_faultdetail(), soap_faultstring(), and soap_faultsubcode().

◆ soap_fault_detail()

SOAP_FMAC3 const char* SOAP_FMAC4 soap_fault_detail ( struct soap * soap )

Definition at line 153 of file soapC.cpp.

 {
     const char **s = soap_faultdetail(soap);
     return s ? *s : NULL;
 }

References NULL, and soap_faultdetail().

Referenced by soap_print_fault(), and soap_sprint_fault().

◆ soap_fault_string()

SOAP_FMAC3 const char* SOAP_FMAC4 soap_fault_string ( struct soap * soap )

Definition at line 132 of file soapC.cpp.

 {
     const char **s = soap_faultstring(soap);
     return s ? *s : NULL;
 }

Referenced by soap_print_fault(), and soap_sprint_fault().

◆ soap_fault_subcode()

SOAP_FMAC3 const char* SOAP_FMAC4 soap_fault_subcode ( struct soap * soap )

Definition at line 116 of file soapC.cpp.

 {
     const char **s = soap_faultsubcode(soap);
     return s ? *s : NULL;
 }

References NULL, and soap_faultsubcode().

Referenced by soap_print_fault(), and soap_sprint_fault().

◆ soap_faultcode()

SOAP_FMAC3 const char** SOAP_FMAC4 soap_faultcode ( struct soap * soap )

Definition at line 90 of file soapC.cpp.

 {
     soap_fault(soap);
     if (soap->fault == NULL)
         return NULL;
     if (soap->version == 2 && soap->fault->SOAP_ENV__Code)
         return (const char**)(void*)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
     return (const char**)(void*)&soap->fault->faultcode;
 }

References soap::fault, SOAP_ENV__Fault::faultcode, NULL, SOAP_ENV__Fault::SOAP_ENV__Code, SOAP_ENV__Code::SOAP_ENV__Value, soap_fault(), and soap::version.

Referenced by http_response(), soap_print_fault(), soap_recv_fault(), soap_set_error(), soap_set_fault(), and soap_sprint_fault().

◆ soap_faultdetail()

SOAP_FMAC3 const char** SOAP_FMAC4 soap_faultdetail ( struct soap * soap )

Definition at line 138 of file soapC.cpp.

 {
     soap_fault(soap);
     if (soap->fault == NULL)
         return NULL;
     if (soap->version == 2)
     {   if (soap->fault->SOAP_ENV__Detail == NULL)
             soap->fault->SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap, -1);
         return (const char**)(void*)&soap->fault->SOAP_ENV__Detail->__any;
     }
     if (soap->fault->detail == NULL)
         soap->fault->detail = soap_new_SOAP_ENV__Detail(soap, -1);
     return (const char**)(void*)&soap->fault->detail->__any;
 }

References SOAP_ENV__Detail::__any, SOAP_ENV__Fault::detail, soap::fault, NULL, SOAP_ENV__Fault::SOAP_ENV__Detail, soap_fault(), soap_new_SOAP_ENV__Detail(), and soap::version.

Referenced by soap_fault_detail(), soap_recv_fault(), soap_send_fault(), and soap_set_error().

◆ soap_faultstring()

SOAP_FMAC3 const char** SOAP_FMAC4 soap_faultstring ( struct soap * soap )

Definition at line 122 of file soapC.cpp.

 {
     soap_fault(soap);
     if (soap->fault == NULL)
         return NULL;
     if (soap->version == 2 && soap->fault->SOAP_ENV__Reason)
         return (const char**)(void*)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
     return (const char**)(void*)&soap->fault->faultstring;
 }

References soap::fault, SOAP_ENV__Fault::faultstring, NULL, SOAP_ENV__Fault::SOAP_ENV__Reason, SOAP_ENV__Reason::SOAP_ENV__Text, soap_fault(), and soap::version.

Referenced by soap_instantiate_SOAP_ENV__Detail(), soap_recv_fault(), soap_send_fault(), soap_set_error(), and soap_set_fault().

◆ soap_faultsubcode()

SOAP_FMAC3 const char** SOAP_FMAC4 soap_faultsubcode ( struct soap * soap )

Definition at line 100 of file soapC.cpp.

 {
     soap_fault(soap);
     if (soap->fault == NULL)
         return NULL;
     if (soap->version == 2 && soap->fault->SOAP_ENV__Code)
     {   if (soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode == NULL)
         {   soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = soap_new_SOAP_ENV__Code(soap, -1);
             if (soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode == NULL)
                 return NULL;
         }
         return (const char**)(void*)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
     }
     return (const char**)(void*)&soap->fault->faultcode;
 }

References soap::fault, NULL, SOAP_ENV__Fault::SOAP_ENV__Code, SOAP_ENV__Code::SOAP_ENV__Subcode, soap_fault(), soap_new_SOAP_ENV__Code(), and soap::version.

Referenced by soap_fault_subcode(), soap_set_error(), and soap_set_fault().

◆ soap_first_block()

SOAP_FMAC1 char* SOAP_FMAC2 soap_first_block	(	struct soap *	soap,
		struct soap_blist *	b
	)

Definition at line 3235 of file stdsoap2.cpp.

 {
   struct soap_bhead *p, *q, *r;
   if (!b)
     b = soap->blist;
   p = b->head;
   if (!p)
     return NULL;
   r = NULL;
   do
   {
     q = p->next;
     p->next = r;
     r = p;
     p = q;
   } while (p);
   b->head = r;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "First block %p\n", (void*)(r + 1)));
   return (char*)(r + 1);
 }

References b, soap::blist, DBGLOG, soap_bhead::next, NULL, and TEST().

Referenced by soap_end_send_flush(), and soap_save_block().

◆ soap_float2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_float2s	(	struct soap *	soap,
		float	n
	)

Definition at line 16556 of file stdsoap2.cpp.

 {
 #if defined(WITH_C_LOCALE)
 # if !defined(WIN32)
   SOAP_LOCALE_T locale;
 # endif
 #else
   char *s;
 #endif
   if (soap_isnan((double)n))
     return "NaN";
   if (soap_ispinff(n))
     return "INF";
   if (soap_isninff(n))
     return "-INF";
 #if defined(WITH_C_LOCALE)
 # ifdef WIN32
   _sprintf_s_l(soap->tmpbuf, _countof(soap->tmpbuf), soap->float_format, SOAP_LOCALE(soap), n);
 # else
   locale = uselocale(SOAP_LOCALE(soap));
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), soap->float_format, n);
   uselocale(locale);
 # endif
 #else
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), soap->float_format, n);
   s = strchr(soap->tmpbuf, ',');        /* convert decimal comma to DP */
   if (s)
     *s = '.';
 #endif
   return soap->tmpbuf;
 }

References soap::float_format, soap_isnan, soap_isninff, soap_ispinff, SOAP_SNPRINTF, and soap::tmpbuf.

Referenced by soap_outfloat().

◆ soap_flush()

SOAP_FMAC1 int SOAP_FMAC2 soap_flush ( struct soap * soap )

Definition at line 867 of file stdsoap2.cpp.

 {
   size_t n = soap->bufidx;
   if (!n)
     return soap->error = soap->fsend(soap, SOAP_STR_EOS, 0); /* force a zero send for HTTP GET and DELETE */
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
   {
     int r;
     if (soap->fpreparesend && (r = soap->fpreparesend(soap, soap->buf, n)) != SOAP_OK)
       return soap->error = r;
   }
 #endif
   soap->bufidx = 0;
 #ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && soap->d_stream)
   {
     soap->d_stream->next_in = (Byte*)soap->buf;
     soap->d_stream->avail_in = (unsigned int)n;
 #ifdef WITH_GZIP
     soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)n);
 #endif
     do
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream->avail_in));
       if (deflate(soap->d_stream, Z_NO_FLUSH) != Z_OK)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
         return soap->error = SOAP_ZLIB_ERROR;
       }
       if (!soap->d_stream->avail_out)
       {
         if (soap_flush_raw(soap, soap->z_buf, sizeof(soap->buf)))
           return soap->error;
         soap->d_stream->next_out = (Byte*)soap->z_buf;
         soap->d_stream->avail_out = sizeof(soap->buf);
       }
     } while (soap->d_stream->avail_in);
     return SOAP_OK;
   }
 #endif
   return soap_flush_raw(soap, soap->buf, n);
 }

References soap::buf, soap::bufidx, crc32(), soap::d_stream, DBGLOG, deflate(), soap::error, soap::fpreparesend, soap::fsend, soap::mode, SOAP_ENC_ZLIB, soap_flush_raw(), SOAP_IO, SOAP_IO_STORE, SOAP_OK, SOAP_STR_EOS, SOAP_ZLIB_ERROR, TEST(), soap::z_buf, soap::z_crc, Z_NO_FLUSH, and Z_OK.

Referenced by soap_end_send_flush(), soap_response(), soap_send_raw(), and soap_try_connect_command().

◆ soap_flush_raw()

SOAP_FMAC1 int SOAP_FMAC2 soap_flush_raw	(	struct soap *	soap,
		const char *	s,
		size_t	n
	)

Definition at line 916 of file stdsoap2.cpp.

 {
   if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
   {
     void *t;
     t = soap_push_block(soap, NULL, n);
     if (!t)
       return soap->error = SOAP_EOM;
     (void)soap_memcpy(t, n, (const void*)s, n);
     return SOAP_OK;
   }
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
   {
     char t[24];
     (SOAP_SNPRINTF(t, sizeof(t), 20), &"\r\n%lX\r\n"[soap->chunksize ? 0 : 2], (unsigned long)n);
     DBGMSG(SENT, t, strlen(t));
     soap->error = soap->fsend(soap, t, strlen(t));
     if (soap->error)
       return soap->error;
     soap->chunksize += n;
   }
   DBGMSG(SENT, s, n);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send %u bytes to socket=%d/fd=%d\n", (unsigned int)n, (int)soap->socket, soap->sendfd));
 #endif
   return soap->error = soap->fsend(soap, s, n);
 }

References soap::chunksize, DBGLOG, DBGMSG, soap::error, soap::fsend, soap::mode, NULL, soap::sendfd, SOAP_EOM, SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, soap_memcpy, SOAP_OK, soap_push_block(), SOAP_SNPRINTF, soap::socket, and TEST().

Referenced by soap_end_send_flush(), soap_flush(), and soap_send_raw().

◆ soap_force_closesock()

SOAP_FMAC1 int SOAP_FMAC2 soap_force_closesock ( struct soap * soap )

Definition at line 7233 of file stdsoap2.cpp.

 {
   soap->keep_alive = 0;
   if (soap_valid_socket(soap->socket) && soap->fclosesocket)
   {
     soap->fclosesocket(soap, soap->socket);
     soap->socket = SOAP_INVALID_SOCKET;
   }
   return soap->error;
 }

References soap::error, soap::fclosesocket, soap::keep_alive, SOAP_INVALID_SOCKET, soap_valid_socket, and soap::socket.

◆ soap_free()

SOAP_FMAC1 void SOAP_FMAC2 soap_free ( struct soap * soap )

Definition at line 9582 of file stdsoap2.cpp.

 {
   soap_done(soap);
 #ifdef __cplusplus
   SOAP_DELETE_UNMANAGED(soap);
 #else
   SOAP_FREE_UNMANAGED(soap);
 #endif
 }

References SOAP_DELETE_UNMANAGED, soap_done(), and SOAP_FREE_UNMANAGED.

Referenced by process_message(), and soap_copy().

◆ soap_free_stream()

SOAP_FMAC1 void SOAP_FMAC2 soap_free_stream ( struct soap * soap )

Definition at line 12006 of file stdsoap2.cpp.

 {
   soap->socket = SOAP_INVALID_SOCKET;
   soap->sendsk = SOAP_INVALID_SOCKET;
   soap->recvsk = SOAP_INVALID_SOCKET;
 #ifdef WITH_OPENSSL
   soap->bio = NULL;
   soap->ctx = NULL;
   soap->ssl = NULL;
 #endif
 #ifdef WITH_GNUTLS
   soap->xcred = NULL;
   soap->acred = NULL;
   soap->cache = NULL;
   soap->session = NULL;
   soap->dh_params = NULL;
   soap->rsa_params = NULL;
 #endif
 #ifdef WITH_SYSTEMSSL
   soap->ctx = (gsk_handle)NULL;
   soap->ssl = (gsk_handle)NULL;
 #endif
 #ifdef WITH_ZLIB
   if (soap->z_buf)
     SOAP_FREE(soap, soap->z_buf);
   soap->z_buf = NULL;
 #endif
 }

References soap::bio, soap::ctx, soap::dh_params, NULL, soap::recvsk, soap::rsa_params, soap::sendsk, soap::session, SOAP_FREE, SOAP_INVALID_SOCKET, soap::socket, soap::ssl, and soap::z_buf.

◆ soap_free_temp()

SOAP_FMAC1 void SOAP_FMAC2 soap_free_temp ( struct soap * soap )

Definition at line 11513 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp, *tq;
   struct Namespace *ns;
   soap_free_ns(soap);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free any remaining temp blocks\n"));
   while (soap->blist)
     soap_end_block(soap, NULL);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute storage\n"));
   for (tp = soap->attributes; tp; tp = tq)
   {
     tq = tp->next;
     if (tp->value)
       SOAP_FREE(soap, tp->value);
     SOAP_FREE(soap, tp);
   }
   soap->attributes = NULL;
 #ifdef WITH_FAST
   if (soap->labbuf)
     SOAP_FREE(soap, soap->labbuf);
   soap->labbuf = NULL;
   soap->lablen = 0;
   soap->labidx = 0;
 #endif
   ns = soap->local_namespaces;
   if (ns)
   {
     for (; ns->id; ns++)
     {
       if (ns->out)
       {
         SOAP_FREE(soap, ns->out);
         ns->out = NULL;
       }
     }
     SOAP_FREE(soap, soap->local_namespaces);
     soap->local_namespaces = NULL;
   }
 #ifndef WITH_LEANER
   while (soap->xlist)
   {
     struct soap_xlist *xp = soap->xlist->next;
     SOAP_FREE(soap, soap->xlist);
     soap->xlist = xp;
   }
 #endif
 #ifndef WITH_NOIDREF
   soap_free_iht(soap);
 #endif
   soap_free_pht(soap);
 }

References soap::attributes, soap::blist, DBGLOG, soap::labbuf, soap::labidx, soap::lablen, soap::local_namespaces, soap_attribute::next, soap_xlist::next, Namespace::ns, NULL, soap_end_block(), SOAP_FREE, soap_free_iht(), soap_free_ns(), soap_free_pht(), TEST(), soap_attribute::value, and soap::xlist.

Referenced by soap_begin(), soap_begin_recv(), soap_done(), soap_end(), soap_PATCH__QName(), soap_PATCH_byte(), soap_PATCH_int(), soap_PATCH_ns1__executeCommand(), soap_PATCH_ns1__executeCommandResponse(), soap_PATCH_SOAP_ENV__Code(), soap_PATCH_SOAP_ENV__Detail(), soap_PATCH_SOAP_ENV__Fault(), soap_PATCH_SOAP_ENV__Header(), soap_PATCH_SOAP_ENV__Reason(), soap_PATCH_string(), soap_POST_send__QName(), soap_POST_send_byte(), soap_POST_send_int(), soap_POST_send_ns1__executeCommand(), soap_POST_send_ns1__executeCommandResponse(), soap_POST_send_SOAP_ENV__Code(), soap_POST_send_SOAP_ENV__Detail(), soap_POST_send_SOAP_ENV__Fault(), soap_POST_send_SOAP_ENV__Header(), soap_POST_send_SOAP_ENV__Reason(), soap_POST_send_string(), soap_PUT__QName(), soap_PUT_byte(), soap_PUT_int(), soap_PUT_ns1__executeCommand(), soap_PUT_ns1__executeCommandResponse(), soap_PUT_SOAP_ENV__Code(), soap_PUT_SOAP_ENV__Detail(), soap_PUT_SOAP_ENV__Fault(), soap_PUT_SOAP_ENV__Header(), soap_PUT_SOAP_ENV__Reason(), soap_PUT_string(), soap_write__QName(), soap_write_byte(), soap_write_int(), soap_write_ns1__executeCommand(), soap_write_ns1__executeCommandResponse(), soap_write_SOAP_ENV__Code(), soap_write_SOAP_ENV__Detail(), soap_write_SOAP_ENV__Fault(), soap_write_SOAP_ENV__Header(), soap_write_SOAP_ENV__Reason(), and soap_write_string().

◆ soap_get()

SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_get ( struct soap * soap )

Definition at line 1959 of file stdsoap2.cpp.

 {
   soap_wchar c;
   c = soap->ahead;
   if (c)
   {
     if ((int)c != EOF)
       soap->ahead = 0;
   }
   else
   {
     c = soap_get1(soap);
   }
   while ((int)c != EOF)
   {
     if (soap->cdata)
     {
       if (c == ']')
       {
         c = soap_get1(soap);
         if (c == ']')
         {
           c = soap_get0(soap);
           if (c == '>')
           {
             soap->cdata = 0;
             c = soap_get1(soap);
             c = soap_get1(soap);
           }
           else
           {
             soap_unget(soap, ']');
             return ']';
           }
         }
         else
         {
           soap_revget1(soap);
           return ']';
         }
       }
       else
       {
         return c;
       }
     }
     switch (c)
     {
       case '<':
         do
         {
           c = soap_get1(soap);
         } while (soap_coblank(c));
         if (c == '!' || c == '?' || c == '%')
         {
           int k = 1;
           if (c == '!')
           {
             c = soap_get1(soap);
             if (c == '[')
             {
               do
               {
                 c = soap_get1(soap);
               } while ((int)c != EOF && c != '[');
               if ((int)c == EOF)
                 break;
               soap->cdata = 1;
               c = soap_get1(soap);
               continue;
             }
             if (c == '-' && (c = soap_get1(soap)) == '-')
             {
               do
               {
                 c = soap_get1(soap);
                 if (c == '-' && (c = soap_get1(soap)) == '-')
                   break;
               } while ((int)c != EOF);
             }
           }
           else if (c == '?')
           {
             c = soap_getpi(soap);
           }
           while ((int)c != EOF)
           {
             if (c == '<')
             {
               k++;
             }
             else if (c == '>')
             {
               if (--k <= 0)
                 break;
             }
             c = soap_get1(soap);
           }
           if ((int)c == EOF)
             break;
           c = soap_get1(soap);
           continue;
         }
         if (c == '/')
           return SOAP_TT;
         soap_revget1(soap);
         return SOAP_LT;
       case '>':
         return SOAP_GT;
       case '"':
         return SOAP_QT;
       case '\'':
         return SOAP_AP;
       case '&':
         return soap_char(soap) | 0x80000000;
     }
     break;
   }
   return c;
 }

References soap::ahead, mpq::c, soap::cdata, SOAP_AP, soap_char(), soap_coblank, soap_get0, soap_get1, soap_getpi(), SOAP_GT, SOAP_LT, SOAP_QT, soap_revget1, SOAP_TT, and soap_unget.

Referenced by soap_element_end_in(), soap_getattrval(), soap_getbase64(), soap_gethex(), soap_getutf8(), soap_ignore(), soap_peek_element(), soap_string_in(), and soap_value().

◆ soap_GET()

SOAP_FMAC1 int SOAP_FMAC2 soap_GET	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action
	)

Definition at line 21249 of file stdsoap2.cpp.

 {
   return soap_connect_command(soap, SOAP_GET, endpoint, action);
 }

References soap_connect_command(), and SOAP_GET.

Referenced by soap_GET__QName(), soap_GET_byte(), soap_GET_int(), soap_GET_ns1__executeCommand(), soap_GET_ns1__executeCommandResponse(), soap_GET_SOAP_ENV__Code(), soap_GET_SOAP_ENV__Detail(), soap_GET_SOAP_ENV__Fault(), soap_GET_SOAP_ENV__Header(), soap_GET_SOAP_ENV__Reason(), and soap_GET_string().

◆ soap_getbase64()

SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_getbase64	(	struct soap *	soap,
		int *	n,
		int	malloc_flag
	)

Definition at line 2523 of file stdsoap2.cpp.

 {
   size_t l = 0;
   (void)malloc_flag;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_string_in(soap, 0, -1, -1, NULL);
     return (unsigned char*)soap_base642s(soap, soap->dom->text, NULL, 0, n);
   }
 #endif
 #ifdef WITH_FAST
   soap->labidx = 0;
   for (;;)
   {
     size_t i, k;
     char *s;
     if (soap_append_lab(soap, NULL, 2))
       return NULL;
     s = soap->labbuf + soap->labidx;
     k = soap->lablen - soap->labidx;
     soap->labidx = 3 * (soap->lablen / 3);
     if (k > 2)
     {
       for (i = 0; i < k - 2; i += 3)
       {
         unsigned long m = 0;
         int j = 0;
         do
         {
           soap_wchar c = soap_get(soap);
           if (c < SOAP_AP)
             c &= 0x7FFFFFFF;
           if (c == '=' || c < 0)
           {
             unsigned char *p = NULL;
             switch (j)
             {
               case 2:
                 *s++ = (char)((m >> 4) & 0xFF);
                 i++;
                 break;
               case 3:
                 *s++ = (char)((m >> 10) & 0xFF);
                 *s++ = (char)((m >> 2) & 0xFF);
                 i += 2;
             }
             l = soap->lablen + i - k;
             if (n)
               *n = (int)l;
             if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
               soap->error = SOAP_LENGTH;
             else
             {
               p = (unsigned char*)soap_malloc(soap, l);
               if (p)
                 (void)soap_memcpy((void*)p, l, (const void*)soap->labbuf, l);
             }
             if (c >= 0)
             {
               while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
                 continue;
             }
             soap_unget(soap, c);
             return p;
           }
           c -= '+';
           if (c >= 0 && c <= 79)
           {
             int b = soap_base64i[c];
             if (b >= 64)
             {
               soap->error = SOAP_TYPE;
               return NULL;
             }
             m = (m << 6) + b;
             j++;
           }
           else if (!soap_coblank(c + '+'))
           {
             soap->error = SOAP_TYPE;
             return NULL;
           }
         } while (j < 4);
         *s++ = (char)((m >> 16) & 0xFF);
         *s++ = (char)((m >> 8) & 0xFF);
         *s++ = (char)(m & 0xFF);
       }
       l = soap->lablen;
       if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
       {
         soap->error = SOAP_LENGTH;
         return NULL;
       }
     }
   }
 #else
   if (soap_alloc_block(soap) == NULL)
     return NULL;
   for (;;)
   {
     int i;
     char *s = (char*)soap_push_block(soap, NULL, 3 * SOAP_BLKLEN); /* must be multiple of 3 */
     if (!s)
     {
       soap_end_block(soap, NULL);
       return NULL;
     }
     for (i = 0; i < SOAP_BLKLEN; i++)
     {
       unsigned long m = 0;
       int j = 0;
       do
       {
         soap_wchar c = soap_get(soap);
         if (c < SOAP_AP)
           c &= 0x7FFFFFFF;
         if (c == '=' || c < 0)
         {
           unsigned char *p;
           i *= 3;
           switch (j)
           {
             case 2:
               *s++ = (char)((m >> 4) & 0xFF);
               i++;
               l++;
               break;
             case 3:
               *s++ = (char)((m >> 10) & 0xFF);
               *s++ = (char)((m >> 2) & 0xFF);
               l += 2;
               i += 2;
           }
           if (n)
             *n = (int)soap_size_block(soap, NULL, i);
           if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
           {
             soap->error = SOAP_LENGTH;
             soap_end_block(soap, NULL);
             return NULL;
           }
           p = (unsigned char*)soap_save_block(soap, NULL, NULL, 0);
           if (c >= 0)
           {
             while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
               continue;
           }
           soap_unget(soap, c);
           return p;
         }
         c -= '+';
         if (c >= 0 && c <= 79)
         {
           int b = soap_base64i[c];
           if (b >= 64)
           {
             soap->error = SOAP_TYPE;
             return NULL;
           }
           m = (m << 6) + b;
           j++;
         }
         else if (!soap_coblank(c + '+'))
         {
           soap->error = SOAP_TYPE;
           return NULL;
         }
       } while (j < 4);
       *s++ = (char)((m >> 16) & 0xFF);
       *s++ = (char)((m >> 8) & 0xFF);
       *s++ = (char)(m & 0xFF);
       l += 3;
     }
     if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
     {
       soap->error = SOAP_LENGTH;
       soap_end_block(soap, NULL);
       return NULL;
     }
   }
 #endif
 }

References b, mpq::c, soap::dom, soap::error, mpq::l, soap::labbuf, soap::labidx, soap::lablen, soap::maxlength, soap::mode, NULL, SOAP_AP, soap_append_lab(), soap_base642s(), soap_base64i, soap_coblank, soap_get(), SOAP_LENGTH, SOAP_LT, soap_malloc(), soap_memcpy, soap_string_in(), SOAP_TT, SOAP_TYPE, soap_unget, SOAP_XML_DOM, and soap_dom_element::text.

◆ soap_getchar()

SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_getchar ( struct soap * soap )

Definition at line 1742 of file stdsoap2.cpp.

 {
   soap_wchar c;
   c = soap->ahead;
   if (c)
   {
     if ((int)c != EOF)
       soap->ahead = 0;
     return c;
   }
   return soap_get1(soap);
 }

References soap::ahead, mpq::c, and soap_get1.

Referenced by soap_begin_recv(), soap_getdimehdr(), soap_getline(), soap_getpi(), soap_move(), soap_peek_element(), soap_recv_mime_attachment(), and soap_string_in().

◆ soap_getdime()

SOAP_FMAC1 int SOAP_FMAC2 soap_getdime ( struct soap * soap )

Definition at line 19439 of file stdsoap2.cpp.

 {
   if (soap->dime.buflen || soap->dime.chunksize)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skip remainder of SOAP in DIME (%u bytes or %u bytes in chunk left)\n", (unsigned int)soap->dime.buflen, (unsigned int)soap->dime.chunksize));
     do
       if (soap_get1(soap) == (int)EOF)
         return soap->error = SOAP_CHK_EOF;
     while (soap->dime.buflen || soap->dime.chunksize);
     if (soap_move(soap, (size_t)(-(long)soap->dime.size&3)))
       return soap->error = SOAP_CHK_EOF;
     if (!(soap->mode & SOAP_ENC_DIME))
       return SOAP_OK;
   }
   else
   {
     if (soap_move(soap, (size_t)(((soap->dime.size+3)&(~3)) - soap_tell(soap))))
       return soap->error = SOAP_CHK_EOF;
   }
   for (;;)
   {
     struct soap_multipart *content;
     if (soap_getdimehdr(soap))
       break;
     if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) != NULL || soap->error))
     {
       const char *id, *type, *options;
       size_t size, n;
       if (!soap->dime.ptr)
         return soap->error;
       id = soap->dime.id;
       type = soap->dime.type;
       options = soap->dime.options;
       for (;;)
       {
         size = soap->dime.size;
         for (;;)
         {
           n = soap->buflen - soap->bufidx;
           if (size < n)
             n = size;
           soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n);
           if (soap->error)
             break;
           size -= n;
           if (!size)
           {
             soap->bufidx += n;
             break;
           }
           if (soap_recv(soap))
           {
             soap->error = SOAP_EOF;
             goto end;
           }
         }
         if (soap_move(soap, (size_t)(-(long)soap->dime.size&3)))
         {
           soap->error = SOAP_EOF;
           break;
         }
         if (!(soap->dime.flags & SOAP_DIME_CF))
           break;
         if (soap_getdimehdr(soap))
           break;
       }
 end:
       if (soap->fdimewriteclose)
         soap->fdimewriteclose(soap, (void*)soap->dime.ptr);
       soap->dime.size = 0;
       soap->dime.id = id;
       soap->dime.type = type;
       soap->dime.options = options;
     }
     else if ((soap->dime.flags & SOAP_DIME_CF))
     {
       const char *id, *type, *options;
       id = soap->dime.id;
       type = soap->dime.type;
       options = soap->dime.options;
       if (soap_alloc_block(soap) == NULL)
         return soap->error = SOAP_EOM;
       for (;;)
       {
         soap_wchar c;
         size_t i;
         char *s;
         if (soap->dime.size > SOAP_MAXDIMESIZE)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu exceeds SOAP_MAXDIMESIZE=%lu\n", (unsigned long)soap->dime.size, (unsigned long)SOAP_MAXDIMESIZE));
           return soap->error = SOAP_DIME_ERROR;
         }
         s = (char*)soap_push_block(soap, NULL, soap->dime.size);
         if (!s)
           return soap->error = SOAP_EOM;
         for (i = soap->dime.size; i > 0; i--)
         {
           c = soap_get1(soap);
           if ((int)c == EOF)
             return soap->error = SOAP_EOF;
           *s++ = (char)c;
         }
         if (soap_move(soap, (size_t)(-(long)soap->dime.size&3)))
           return soap->error = SOAP_EOF;
         if (!(soap->dime.flags & SOAP_DIME_CF))
           break;
         if (soap_getdimehdr(soap))
           return soap->error;
       }
       soap->dime.size = soap->blist->size;
       if (soap->dime.size + 1 > soap->dime.size)
         soap->blist->size++; /* allocate one more byte in blist for the terminating '\0' */
       soap->dime.ptr = soap_save_block(soap, NULL, NULL, 0);
       if (!soap->dime.ptr)
         return soap->error;
       if (soap->dime.size + 1 > soap->dime.size)
         soap->dime.ptr[soap->dime.size] = '\0'; /* make 0-terminated, just in case even though this is binary data */
       soap->dime.id = id;
       soap->dime.type = type;
       soap->dime.options = options;
     }
     else
     {
       soap->dime.ptr = soap_getdimefield(soap, soap->dime.size);
     }
     content = soap_alloc_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size);
     if (!content)
       return soap->error = SOAP_EOM;
     content->id = soap->dime.id;
     content->type = soap->dime.type;
     content->options = soap->dime.options;
     if (soap->error)
       return soap->error;
     soap_resolve_attachment(soap, content);
   }
   if (soap->error != SOAP_DIME_END)
     return soap->error;
   return soap->error = SOAP_OK;
 }

References soap::blist, soap::buf, soap::bufidx, soap_dime::buflen, soap::buflen, mpq::c, soap_dime::chunksize, DBGLOG, soap::dime, soap::error, soap::fdimewrite, soap::fdimewriteclose, soap::fdimewriteopen, soap_dime::first, soap_dime::flags, soap_dime::id, soap_multipart::id, if(), soap_dime::last, soap::mode, NULL, soap_dime::options, soap_multipart::options, soap_dime::ptr, soap_blist::size, soap_dime::size, soap_multipart::size, soap_alloc_block(), soap_alloc_multipart(), SOAP_CHK_EOF, SOAP_DIME_CF, SOAP_DIME_END, SOAP_DIME_ERROR, SOAP_ENC_DIME, SOAP_EOF, SOAP_EOM, soap_get1, soap_getdimefield(), soap_getdimehdr(), SOAP_MAXDIMESIZE, soap_move(), SOAP_OK, soap_push_block(), soap_recv(), soap_resolve_attachment(), soap_save_block(), soap_tell(), TEST(), soap_dime::type, and soap_multipart::type.

Referenced by soap_end_recv().

◆ soap_getdimehdr()

SOAP_FMAC1 int SOAP_FMAC2 soap_getdimehdr ( struct soap * soap )

Definition at line 19391 of file stdsoap2.cpp.

 {
   soap_wchar c;
   char *s;
   int i;
   unsigned char tmp[12];
   size_t optlen, idlen, typelen;
   if (!(soap->mode & SOAP_ENC_DIME))
     return soap->error = SOAP_DIME_END;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME header\n"));
   s = (char*)tmp;
   for (i = 12; i > 0; i--)
   {
     c = soap_getchar(soap);
     if ((int)c == EOF)
       return soap->error = SOAP_CHK_EOF;
     *s++ = (char)c;
   }
   if ((tmp[0] & 0xF8) != SOAP_DIME_VERSION)
     return soap->error = SOAP_DIME_MISMATCH;
   soap->dime.flags = (tmp[0] & 0x7) | (tmp[1] & 0xF0);
   optlen = (tmp[2] << 8) | tmp[3];
   idlen = (tmp[4] << 8) | tmp[5];
   typelen = (tmp[6] << 8) | tmp[7];
   soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu flags=0x%X\n", (unsigned long)soap->dime.size, soap->dime.flags));
   soap->dime.options = soap_getdimefield(soap, optlen);
   if (!soap->dime.options && soap->error)
     return soap->error;
   soap->dime.id = soap_getdimefield(soap, idlen);
   if (!soap->dime.id && soap->error)
     return soap->error;
   soap->dime.type = soap_getdimefield(soap, typelen);
   if (!soap->dime.type && soap->error)
     return soap->error;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME flags=%x id='%s', type='%s', options='%s'\n", soap->dime.flags, soap->dime.id ? soap->dime.id : SOAP_STR_EOS, soap->dime.type ? soap->dime.type : "", soap->dime.options ? soap->dime.options+4 : SOAP_STR_EOS));
   if ((soap->dime.flags & SOAP_DIME_ME))
     soap->mode &= ~SOAP_ENC_DIME;
   return SOAP_OK;
 }

References mpq::c, DBGLOG, soap::dime, soap::error, soap_dime::flags, soap_dime::id, soap::mode, soap_dime::options, soap_dime::size, SOAP_CHK_EOF, SOAP_DIME_END, SOAP_DIME_ME, SOAP_DIME_MISMATCH, SOAP_DIME_VERSION, SOAP_ENC_DIME, soap_getchar(), soap_getdimefield(), SOAP_OK, SOAP_STR_EOS, TEST(), and soap_dime::type.

Referenced by soap_begin_recv(), and soap_getdime().

◆ soap_getfault()

SOAP_FMAC3 int SOAP_FMAC4 soap_getfault ( struct soap * soap )

Definition at line 85 of file soapC.cpp.

 {
     return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
 }

Referenced by soap_recv_fault().

◆ soap_getheader()

SOAP_FMAC3 int SOAP_FMAC4 soap_getheader ( struct soap * soap )

Definition at line 26 of file soapC.cpp.

 {
     soap->part = SOAP_IN_HEADER;
     soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", soap->header, NULL);
     soap->part = SOAP_END_HEADER;
     return soap->header == NULL;
 }

References soap::header, NULL, soap::part, SOAP_END_HEADER, SOAP_IN_HEADER, and soap_in_SOAP_ENV__Header().

Referenced by soap_recv_header().

◆ soap_gethex()

SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_gethex	(	struct soap *	soap,
		int *	n
	)

Definition at line 2339 of file stdsoap2.cpp.

 {
   size_t l = 0;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_string_in(soap, 0, -1, -1, NULL);
     return (unsigned char*)soap_hex2s(soap, soap->dom->text, NULL, 0, n);
   }
 #endif
 #ifdef WITH_FAST
   soap->labidx = 0;
   for (;;)
   {
     char *s;
     size_t i, k;
     if (soap_append_lab(soap, NULL, 0))
       return NULL;
     s = soap->labbuf + soap->labidx;
     k = soap->lablen - soap->labidx;
     soap->labidx = soap->lablen;
     for (i = 0; i < k; i++)
     {
       char d1, d2;
       soap_wchar c;
       c = soap_get(soap);
       if (soap_isxdigit(c))
       {
         d1 = (char)c;
         c = soap_get(soap);
         if (soap_isxdigit(c))
         {
           d2 = (char)c;
         }
         else
         {
           soap->error = SOAP_TYPE;
           return NULL;
         }
       }
       else
       {
         unsigned char *p = NULL;
         l = soap->lablen + i - k;
         soap_unget(soap, c);
         if (n)
           *n = (int)l;
         if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
         {
           soap->error = SOAP_LENGTH;
         }
         else
         {
           p = (unsigned char*)soap_malloc(soap, l);
           if (p)
             (void)soap_memcpy((void*)p, l, (const void*)soap->labbuf, l);
         }
         return p;
       }
       *s++ = (char)(((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'));
     }
     l = soap->lablen;
     if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
     {
       soap->error = SOAP_LENGTH;
       return NULL;
     }
   }
 #else
   if (soap_alloc_block(soap) == NULL)
     return NULL;
   for (;;)
   {
     int i;
     char *s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN);
     if (!s)
     {
       soap_end_block(soap, NULL);
       return NULL;
     }
     for (i = 0; i < SOAP_BLKLEN; i++)
     {
       char d1, d2;
       soap_wchar c = soap_get(soap);
       if (soap_isxdigit(c))
       {
         d1 = (char)c;
         c = soap_get(soap);
         if (soap_isxdigit(c))
           d2 = (char)c;
         else
         {
           soap_end_block(soap, NULL);
           soap->error = SOAP_TYPE;
           return NULL;
         }
       }
       else
       {
         unsigned char *p;
         soap_unget(soap, c);
         if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
         {
           soap->error = SOAP_LENGTH;
           soap_end_block(soap, NULL);
           return NULL;
         }
         if (n)
           *n = (int)soap_size_block(soap, NULL, i);
         p = (unsigned char*)soap_save_block(soap, NULL, NULL, 0);
         return p;
       }
       *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
       l++;
     }
     if (soap->maxlength > 0 && l > (size_t)soap->maxlength)
     {
       soap->error = SOAP_LENGTH;
       soap_end_block(soap, NULL);
       return NULL;
     }
   }
 #endif
 }

References mpq::c, d1, soap::dom, soap::error, mpq::l, soap::labbuf, soap::labidx, soap::lablen, soap::maxlength, soap::mode, NULL, soap_alloc_block(), soap_append_lab(), SOAP_BLKLEN, soap_end_block(), soap_get(), soap_hex2s(), soap_isxdigit(), SOAP_LENGTH, soap_malloc(), soap_memcpy, soap_push_block(), soap_save_block(), soap_size_block(), soap_string_in(), SOAP_TYPE, soap_unget, SOAP_XML_DOM, and soap_dom_element::text.

◆ soap_getline()

SOAP_FMAC1 int SOAP_FMAC2 soap_getline	(	struct soap *	soap,
		char *	buf,
		int	len
	)

Definition at line 19054 of file stdsoap2.cpp.

 {
   char *s = buf;
   int i = len;
   soap_wchar c = 0;
   for (;;)
   {
     while (i > 1)
     {
       c = soap_getchar(soap);
       if (c == '\r' || c == '\n')
         break;
       if ((int)c == EOF)
         return soap->error = SOAP_CHK_EOF;
       *s++ = (char)c;
       i--;
     }
     *s = '\0';
     if (c != '\n')
       c = soap_getchar(soap); /* got \r or something else, now get \n */
     if (c == '\n')
     {
       if (i == len) /* empty line: end of HTTP/MIME header */
         break;
       c = soap_get0(soap);
       if (c != ' ' && c != '\t') /* HTTP line continuation? */
         break;
     }
     else if ((int)c == EOF)
     {
       return soap->error = SOAP_CHK_EOF;
     }
     else if (i <= 1)
     {
       return soap->error = SOAP_HDR;
     }
   }
   return SOAP_OK;
 }

References mpq::c, soap::error, SOAP_CHK_EOF, soap_get0, soap_getchar(), SOAP_HDR, and SOAP_OK.

Referenced by http_parse(), and soap_getmimehdr().

◆ soap_getmime()

SOAP_FMAC1 int SOAP_FMAC2 soap_getmime ( struct soap * soap )

Definition at line 19660 of file stdsoap2.cpp.

 {
   while (soap_recv_mime_attachment(soap, NULL))
     continue;
   return soap->error;
 }

References soap::error, NULL, and soap_recv_mime_attachment().

Referenced by soap_end_recv().

◆ soap_getmimehdr()

SOAP_FMAC1 int SOAP_FMAC2 soap_getmimehdr ( struct soap * soap )

Definition at line 19586 of file stdsoap2.cpp.

 {
   struct soap_multipart *content;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get MIME header\n"));
   do
   {
     if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
       return soap->error;
   } while (!*soap->msgbuf);
   if (soap->msgbuf[0] == '-' && soap->msgbuf[1] == '-')
   {
     char *s = soap->msgbuf + strlen(soap->msgbuf) - 1;
     /* remove white space */
     while (soap_coblank((soap_wchar)*s))
       s--;
     s[1] = '\0';
     if (soap->mime.boundary)
     {
       if (strcmp(soap->msgbuf + 2, soap->mime.boundary))
         return soap->error = SOAP_MIME_ERROR;
     }
     else
     {
       soap->mime.boundary = soap_strdup(soap, soap->msgbuf + 2);
       if (!soap->mime.boundary)
         return soap->error = SOAP_EOM;
     }
     if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
       return soap->error;
   }
   if (soap_set_mime_attachment(soap, NULL, 0, SOAP_MIME_NONE, NULL, NULL, NULL, NULL))
     return soap->error = SOAP_EOM;
   content = soap->mime.last;
   for (;;)
   {
     char *key = soap->msgbuf;
     char *val;
     if (!*key)
       break;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME header: %s\n", key));
     val = strchr(soap->msgbuf, ':');
     if (val)
     {
       *val = '\0';
       do
       {
         val++;
       } while (*val && *val <= 32);
       if (!soap_tag_cmp(key, "Content-ID"))
         content->id = soap_strdup(soap, val);
       else if (!soap_tag_cmp(key, "Content-Location"))
         content->location = soap_strdup(soap, val);
       else if (!content->id && !soap_tag_cmp(key, "Content-Disposition"))
         content->id = soap_strdup(soap, soap_http_header_attribute(soap, val, "name"));
       else if (!soap_tag_cmp(key, "Content-Type"))
         content->type = soap_strdup(soap, val);
       else if (!soap_tag_cmp(key, "Content-Description"))
         content->description = soap_strdup(soap, val);
       else if (!soap_tag_cmp(key, "Content-Transfer-Encoding"))
         content->encoding = (enum soap_mime_encoding)soap_code_int(mime_codes, val, (LONG64)SOAP_MIME_NONE);
     }
     if (soap_getline(soap, key, sizeof(soap->msgbuf)))
       return soap->error;
   }
   return SOAP_OK;
 }

References soap_mime::boundary, DBGLOG, soap_multipart::description, soap_multipart::encoding, soap::error, soap_multipart::id, soap_mime::last, soap_multipart::location, LONG64, soap::mime, mime_codes, soap::msgbuf, NULL, soap_coblank, soap_code_int(), SOAP_EOM, soap_getline(), soap_http_header_attribute(), SOAP_MIME_ERROR, SOAP_MIME_NONE, SOAP_OK, soap_set_mime_attachment(), soap_strdup(), soap_tag_cmp(), TEST(), and soap_multipart::type.

Referenced by soap_begin_recv(), and soap_recv_mime_attachment().

◆ soap_getoffsets()

SOAP_FMAC1 int SOAP_FMAC2 soap_getoffsets	(	const char *	attr,
		const int *	size,
		int *	offset,
		int	dim
	)

Definition at line 3481 of file stdsoap2.cpp.

 {
   int i, j = 0;
   if (offset)
   {
     for (i = 0; i < dim && attr && *attr; i++)
     {
       attr++;
       j *= size[i];
       j += offset[i] = (int)soap_strtol(attr, NULL, 10);
       attr = strchr(attr, ',');
     }
   }
   else
   {
     for (i = 0; i < dim && attr && *attr; i++)
     {
       attr++;
       j *= size[i];
       j += (int)soap_strtol(attr, NULL, 10);
       attr = strchr(attr, ',');
     }
   }
   return j;
 }

References NULL, soap_ilist::size, and soap_strtol.

◆ soap_getposition()

SOAP_FMAC1 int SOAP_FMAC2 soap_getposition	(	const char *	attr,
		int *	pos
	)

Definition at line 3512 of file stdsoap2.cpp.

 {
   int i, n;
   if (!*attr)
     return -1;
   n = 0;
   i = 1;
   do
   {
     pos[n++] = (int)soap_strtol(attr + i, NULL, 10);
     while (attr[i] && attr[i] != ',' && attr[i] != ']')
       i++;
     if (attr[i] == ',')
       i++;
   } while (n < SOAP_MAXDIMS && attr[i] && attr[i] != ']');
   return n;
 }

References NULL, pos(), SOAP_MAXDIMS, and soap_strtol.

Referenced by soap_peek_element().

◆ soap_getsizes()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_getsizes	(	const char *	attr,
		int *	size,
		int	dim
	)

Definition at line 3456 of file stdsoap2.cpp.

 {
   size_t i, k, n;
   if (!*attr)
     return 0;
   i = strlen(attr);
   n = 1;
   do
   {
     for (; i > 0; i--)
       if (attr[i - 1] == '[' || attr[i - 1] == ',' || attr[i - 1] == ' ')
         break;
     n *= k = (size_t)soap_strtoul(attr + i, NULL, 10);
     size[--dim] = (int)k;
     if (n > SOAP_MAXARRAYSIZE)
       return 0;
   } while (dim > 0 && --i > 0 && attr[i] != '[');
   return n;
 }

References NULL, soap_ilist::size, SOAP_MAXARRAYSIZE, and soap_strtoul.

◆ soap_getutf8()

SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_getutf8 ( struct soap * soap )

Definition at line 2220 of file stdsoap2.cpp.

 {
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
   soap_wchar c, c1, c2, c3;
 #else
   soap_wchar c, c1, c2, c3, c4;
 #endif
   c = soap->ahead;
   if (c >= 0x80)
     soap->ahead = 0;
   else
     c = (soap_wchar)soap_get(soap);
   if (c < 0x80 || c > 0xFF || (soap->mode & SOAP_ENC_LATIN))
     return c;
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
   c1 = (soap_wchar)soap_get1(soap);
   if (c <= 0xC1 || (c1 & 0xC0) != 0x80)
   {
     soap_revget1(soap);
     return SOAP_UNKNOWN_UNICODE_CHAR;
   }
   c1 &= 0x3F;
   if (c < 0xE0)
     return (((c & 0x1F) << 6) | c1);
   c2 = (soap_wchar)soap_get1(soap);
   if ((c == 0xE0 && c1 < 0x20) || (c2 & 0xC0) != 0x80)
   {
     soap_revget1(soap);
     return SOAP_UNKNOWN_UNICODE_CHAR;
   }
   c2 &= 0x3F;
   if (c < 0xF0)
     return (((c & 0x0F) << 12) | (c1 << 6) | c2);
   c3 = (soap_wchar)soap_get1(soap);
   if ((c == 0xF0 && c1 < 0x10) || (c == 0xF4 && c1 >= 0x10) || c >= 0xF5 || (c3 & 0xC0) != 0x80)
   {
     soap_revget1(soap);
     return SOAP_UNKNOWN_UNICODE_CHAR;
   }
   return (((c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | (c3 & 0x3F));
 #else
   c1 = (soap_wchar)soap_get1(soap);
   if (c < 0xC0 || (c1 & 0xC0) != 0x80)
   {
     soap_revget1(soap);
     /* doesn't look like this is UTF-8, try continue as if ISO-8859-1 */
     return c;
   }
   c1 &= 0x3F;
   if (c < 0xE0)
     return ((soap_wchar)(c & 0x1F) << 6) | c1;
   c2 = (soap_wchar)soap_get1(soap) & 0x3F;
   if (c < 0xF0)
     return ((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2;
   c3 = (soap_wchar)soap_get1(soap) & 0x3F;
   if (c < 0xF8)
     return ((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3;
   c4 = (soap_wchar)soap_get1(soap) & 0x3F;
   if (c < 0xFC)
     return ((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
   return ((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(soap_get1(soap) & 0x3F);
 #endif
 }

References soap::ahead, mpq::c, soap::mode, SOAP_ENC_LATIN, soap_get(), soap_get1, and soap_revget1.

Referenced by soap_getattrval(), soap_peek_element(), soap_string_in(), and soap_wstring_in().

◆ soap_hash()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_hash ( const char * s )

Definition at line 9539 of file stdsoap2.cpp.

 {
   size_t h = 0;
   while (*s)
     h = *s++ + (h << 6) + (h << 16) - h; /* Red Dragon book h = 65599*h + c */
   return h % SOAP_IDHASH;
 }

References SOAP_IDHASH.

Referenced by soap_enter(), and soap_lookup().

◆ soap_header()

SOAP_FMAC3 void SOAP_FMAC4 soap_header ( struct soap * soap )

Definition at line 51 of file soapC.cpp.

 {
     if (soap->header == NULL)
     {   if ((soap->header = soap_new_SOAP_ENV__Header(soap)))
             soap_default_SOAP_ENV__Header(soap, soap->header);
     }
 }

◆ soap_hex2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_hex2s	(	struct soap *	soap,
		const char *	s,
		char *	t,
		size_t	l,
		int *	n
	)

Definition at line 21750 of file stdsoap2.cpp.

 {
   const char *p;
   if (!s || !*s)
   {
     if (n)
       *n = 0;
     if (soap->error)
       return NULL;
     return SOAP_NON_NULL;
   }
   if (!t)
   {
     l = strlen(s) / 2 + 1;      /* make sure enough space for \0 */
     t = (char*)soap_malloc(soap, l);
   }
   if (!t)
     return NULL;
   p = t;
   while (l)
   {
     int d1, d2;
     d1 = *s++;
     if (!d1)
       break;
     d2 = *s++;
     if (!d2)
       break;
     *t++ = (char)(((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'));
     l--;
   }
   if (n)
     *n = (int)(t - p);
   if (l)
     *t = '\0';
   return p;
 }

References d1, soap::error, mpq::l, NULL, soap_malloc(), and SOAP_NON_NULL.

Referenced by soap_gethex().

◆ soap_http_content_type()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_http_content_type	(	struct soap *	soap,
		int	status
	)

Definition at line 21794 of file stdsoap2.cpp.

 {
   if (soap->status != SOAP_GET && soap->status != SOAP_DEL && soap->status != SOAP_CONNECT)
   {
     const char *s = "text/xml; charset=utf-8";
 #ifndef WITH_LEANER
     const char *r = NULL;
     size_t n;
 #endif
     if (((status >= SOAP_FILE && status < SOAP_FILE + 600) || soap->status == SOAP_PUT || soap->status == SOAP_POST_FILE || soap->status == SOAP_PATCH) && soap->http_content && *soap->http_content && !strchr(soap->http_content, 10) && !strchr(soap->http_content, 13))
       s = soap->http_content;
     else if (status == SOAP_HTML)
       s = "text/html; charset=utf-8";
     else if (soap->version == 2)
       s = "application/soap+xml; charset=utf-8";
     soap->http_content = NULL; /* use http_content once (assign new value before each call) */
 #ifndef WITH_LEANER
     if (soap->mode & (SOAP_ENC_DIME | SOAP_ENC_MTOM))
     {
       if ((soap->mode & SOAP_ENC_MTOM))
       {
         if (soap->version == 2)
           r = "application/soap+xml";
         else
           r = "text/xml";
         s = "application/xop+xml";
       }
       else
       {
         s = "application/dime";
       }
     }
     if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary)
     {
       const char *t;
       size_t l;
       (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), strlen(soap->mime.boundary) + 53), "multipart/related; charset=utf-8; boundary=\"%s\"; type=\"", soap->mime.boundary);
       t = strchr(s, ';');
       if (t)
         n = t - s;
       else
         n = strlen(s);
       l = strlen(soap->tmpbuf);
       if (sizeof(soap->tmpbuf) > l + n)
         (void)soap_strncpy(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, s, n);
       if (soap->mime.start)
       {
         l = strlen(soap->tmpbuf);
         (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, strlen(soap->mime.start) + 10), "\"; start=\"%s", soap->mime.start);
       }
       if (r)
       {
         l = strlen(soap->tmpbuf);
         (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, strlen(r) + 15), "\"; start-info=\"%s", r);
       }
       l = strlen(soap->tmpbuf);
       if (sizeof(soap->tmpbuf) > l)
         soap_strcpy(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, "\"");
     }
     else
     {
       soap_strcpy(soap->tmpbuf, sizeof(soap->tmpbuf), s);
     }
     if (status == SOAP_OK && soap->version == 2 && soap->action)
     {
       size_t l = strlen(soap->tmpbuf);
       n = strlen(soap->action);
       (SOAP_SNPRINTF(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, n + 11), "; action=\"%s\"", soap->action);
     }
 #else
     soap_strcpy(soap->tmpbuf, sizeof(soap->tmpbuf), s);
 #endif
     return soap->tmpbuf;
   }
   return NULL;
 }

References soap::action, soap_mime::boundary, soap::http_content, mpq::l, soap::mime, soap::mode, NULL, SOAP_CONNECT, SOAP_DEL, SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_MTOM, SOAP_FILE, SOAP_GET, SOAP_HTML, SOAP_OK, SOAP_PATCH, SOAP_POST_FILE, SOAP_PUT, SOAP_SNPRINTF, soap_strcpy, soap_strncpy, soap_mime::start, soap::status, soap::tmpbuf, and soap::version.

Referenced by soap_puthttphdr().

◆ soap_http_get_body()

SOAP_FMAC1 char* SOAP_FMAC2 soap_http_get_body	(	struct soap *	soap,
		size_t *	len
	)

Definition at line 20895 of file stdsoap2.cpp.

 {
   return soap_http_get_body_prefix(soap, len, NULL);
 }

References NULL, and soap_http_get_body_prefix().

Referenced by soap_begin_recv().

◆ soap_http_get_body_prefix()

SOAP_FMAC1 char* SOAP_FMAC2 soap_http_get_body_prefix	(	struct soap *	soap,
		size_t *	len,
		const char *	prefix
	)

Definition at line 20915 of file stdsoap2.cpp.

 {
   char *s;
   ULONG64 k = soap->length;
   size_t n = 0;
   if (!prefix)
     prefix = SOAP_STR_EOS;
   else
     n = strlen(prefix);
   if (len)
     *len = 0;
   /* check HTTP body, return "" if none */
   if (!k && !(soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK)
     return soap_strdup(soap, prefix);
   /* do not consume DIME or MIME attachments, leave this to soap_end_recv */
   if ((soap->mode & SOAP_ENC_DIME) || (soap->mode & SOAP_ENC_MIME))
     return soap_strdup(soap, prefix);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Parsing HTTP body, prefixed with '%s' (mode=0x%x)\n", prefix, soap->mode));
   if (k && !(soap->mode & SOAP_ENC_ZLIB))
   {
     char *t;
     soap->length = 0;
     /* http content length != 0 and uncompressed body */
     if ((SOAP_MAXALLOCSIZE != 0 && n + k > SOAP_MAXALLOCSIZE) || n + k > (ULONG64)((size_t)-2))
     {
       soap->error = SOAP_EOM;
       return NULL;
     }
     s = t = (char*)soap_malloc(soap, (size_t)k + n + 1);
     if (s)
     {
       size_t i;
       soap_strcpy(t, n + 1, prefix);
       t += n;
       for (i = 0; i < k; i++)
       {
         soap_wchar c = soap_get1(soap);
         if ((int)c == EOF)
           break;
         *t++ = (char)(c & 0xFF);
       }
       *t = '\0';
       if (len)
         *len = n + i;
     }
     else
     {
       soap->error = SOAP_EOM;
       return NULL;
     }
   }
   else
   {
     size_t i, l = 0;
     if (soap_alloc_block(soap) == NULL)
       return NULL;
     if (n)
     {
       s = (char*)soap_push_block(soap, NULL, n);
       if (!s)
         return NULL;
       soap_strcpy(s, n + 1, prefix);
       l += n;
     }
     for (;;)
     {
       size_t k = SOAP_BLKLEN;
       s = (char*)soap_push_block(soap, NULL, k);
       if (!s)
         return NULL;
       for (i = 0; i < k; i++)
       {
         soap_wchar c;
         l++;
         if (l == 0)
         {
           soap->error = SOAP_EOM;
           return NULL;
         }
         c = soap_get1(soap);
         if ((int)c == EOF)
           goto end;
         *s++ = (char)(c & 0xFF);
       }
     }
 end:
     *s = '\0';
     if (len)
       *len = l - 1;
     soap_size_block(soap, NULL, i + 1);
     s = soap_save_block(soap, NULL, NULL, 0);
   }
   return s;
 }

References mpq::c, DBGLOG, soap::error, mpq::l, soap::length, soap::mode, NULL, soap_alloc_block(), SOAP_BLKLEN, SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_ZLIB, SOAP_EOM, soap_get1, SOAP_IO, SOAP_IO_CHUNK, soap_malloc(), SOAP_MAXALLOCSIZE, soap_push_block(), soap_save_block(), soap_size_block(), SOAP_STR_EOS, soap_strcpy, soap_strdup(), TEST(), and ULONG64.

Referenced by soap_http_get_body(), and soap_http_get_form().

◆ soap_http_get_form()

SOAP_FMAC1 char* SOAP_FMAC2 soap_http_get_form ( struct soap * soap )

Definition at line 20905 of file stdsoap2.cpp.

 {
   return soap_http_get_body_prefix(soap, NULL, "?");
 }

References NULL, and soap_http_get_body_prefix().

◆ soap_http_has_body()

SOAP_FMAC1 int SOAP_FMAC2 soap_http_has_body ( struct soap * soap )

Definition at line 20847 of file stdsoap2.cpp.

 {
   return soap->length || (soap->mode & SOAP_ENC_ZLIB) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK;
 }

References soap::length, soap::mode, SOAP_ENC_ZLIB, SOAP_IO, and SOAP_IO_CHUNK.

◆ soap_http_header_attribute()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_http_header_attribute	(	struct soap *	soap,
		const char *	line,
		const char *	key
	)

Definition at line 7858 of file stdsoap2.cpp.

 {
   const char *s = line;
   if (s)
   {
     while (*s)
     {
       short flag;
       s = soap_decode_key(soap->tmpbuf, sizeof(soap->tmpbuf), s);
       flag = soap_tag_cmp(soap->tmpbuf, key);
       s = soap_decode_val(soap->tmpbuf, sizeof(soap->tmpbuf), s);
       if (!flag)
         return soap->tmpbuf;
     }
   }
   return NULL;
 }

References NULL, soap_decode_key(), soap_decode_val(), soap_tag_cmp(), and soap::tmpbuf.

Referenced by http_parse_header(), soap_begin_recv(), and soap_getmimehdr().

◆ soap_http_skip_body()

SOAP_FMAC1 int SOAP_FMAC2 soap_http_skip_body ( struct soap * soap )

Definition at line 20857 of file stdsoap2.cpp.

 {
   ULONG64 k = soap->length;
   /* check HTTP body, return "" if none */
   if (!k && !(soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK)
     return SOAP_OK;
   /* do not consume DIME or MIME attachments, leave this to soap_end_recv */
   if ((soap->mode & SOAP_ENC_DIME) || (soap->mode & SOAP_ENC_MIME))
     return SOAP_OK;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skipping HTTP body (mode=0x%x)\n", soap->mode));
   if (k && !(soap->mode & SOAP_ENC_ZLIB))
   {
     size_t i;
     soap->length = 0;
     for (i = 0; i < k; i++)
     {
       soap_wchar c = soap_get1(soap);
       if ((int)c == EOF)
         break;
     }
   }
   else
   {
     for (;;)
     {
       soap_wchar c = soap_get1(soap);
       if ((int)c == EOF)
         break;
     }
   }
   return SOAP_OK;
 }

References mpq::c, DBGLOG, soap::length, soap::mode, SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_ZLIB, soap_get1, SOAP_IO, SOAP_IO_CHUNK, SOAP_OK, TEST(), and ULONG64.

Referenced by soap_begin_recv(), and soap_recv_empty_response().

◆ soap_id_enter()

SOAP_FMAC1 void* SOAP_FMAC2 soap_id_enter	(	struct soap *	soap,
		const char *	id,
		void *	p,
		int	t,
		size_t	n,
		const char *	type,
		const char *	arrayType,
		void ()(struct soap , int, const char , const char , size_t )	finstantiate,
		int(*)(int, int)	fbase
	)

Definition at line 11054 of file stdsoap2.cpp.

 {
 #ifndef WITH_NOIDREF
   struct soap_ilist *ip;
 #endif
   (void)id; (void)fbase;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enter id='%s' type=%d location=%p size=%lu\n", id, t, p, (unsigned long)n));
   soap->alloced = 0;
   if (!p)
   {
     if (finstantiate)
     {
       p = finstantiate(soap, t, type, arrayType, &n); /* soap->alloced is set in soap_link() */
       t = soap->alloced;
     }
     else
     {
       p = soap_malloc(soap, n);
       soap->alloced = t;
     }
   }
 #ifndef WITH_NOIDREF
   if (!id || !*id)
 #endif
     return p;
 #ifndef WITH_NOIDREF
   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup entry id='%s' for location=%p type=%d\n", id, p, t));
   if (!ip)
   {
     ip = soap_enter(soap, id, t, n); /* new hash table entry for string id */
     if (!ip)
       return NULL;
     ip->ptr = p;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New entry id='%s' type=%d size=%lu location=%p\n", id, t, (unsigned long)n, p));
     if (!soap->alloced)
       ip->shaky = soap_is_shaky(soap, p);
   }
   else if (ip->ptr)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Multiply defined id='%s'\n", id));
     soap_strcpy(soap->id, sizeof(soap->id), id);
     soap->error = SOAP_DUPLICATE_ID;
     return NULL;
   }
   else if ((ip->type != t && (!fbase || !fbase(t, ip->type) || soap_type_punned(soap, ip)))
         || (ip->type == t && ip->size != n && soap_type_punned(soap, ip)))
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enter type incompatibility id='%s' expect type=%d size=%lu got type=%d size=%lu\n", id, ip->type, (unsigned long)ip->size, t, (unsigned long)n));
     (void)soap_id_nullify(soap, id);
     return NULL;
   }
   else
   {
     ip->type = t;
     ip->size = n;
     ip->ptr = p;
     if (!soap->alloced)
       ip->shaky = soap_is_shaky(soap, p);
     if (soap->alloced || !ip->shaky)
     {
       void **q; /* ptr will not change later, so resolve links now */
       if (ip->spine)
         ip->spine[0] = p;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Traversing link chain to resolve id='%s' type=%d\n", ip->id, ip->type));
       q = (void**)ip->link;
       while (q)
       {
         void *r = *q;
         *q = p;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... link %p -> %p\n", (void*)q, p));
         q = (void**)r;
       }
       ip->link = NULL;
     }
   }
   return ip->ptr;
 #endif
 }

References soap::alloced, DBGLOG, soap::error, soap_ilist::id, soap::id, soap_ilist::link, NULL, soap_ilist::ptr, soap_ilist::shaky, soap_ilist::size, SOAP_DUPLICATE_ID, soap_enter(), soap_id_nullify(), soap_is_shaky(), soap_lookup(), soap_malloc(), soap_strcpy, soap_type_punned(), soap_ilist::spine, TEST(), and soap_ilist::type.

Referenced by soap_in_ns1__executeCommand(), soap_in_ns1__executeCommandResponse(), soap_in_SOAP_ENV__Code(), soap_in_SOAP_ENV__Detail(), soap_in_SOAP_ENV__Fault(), soap_in_SOAP_ENV__Header(), soap_in_SOAP_ENV__Reason(), soap_inbyte(), soap_indateTime(), soap_indouble(), soap_infloat(), soap_inint(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_instring(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), soap_inunsignedShort(), and soap_inwstring().

◆ soap_id_forward()

SOAP_FMAC1 void* SOAP_FMAC2 soap_id_forward	(	struct soap *	soap,
		const char *	id,
		void *	p,
		size_t	i,
		int	t,
		int	tt,
		size_t	n,
		unsigned int	k,
		void()(struct soap , int, int, void , size_t, const void , void **)	finsert,
		int(*)(int, int)	fbase
	)

Definition at line 10990 of file stdsoap2.cpp.

 {
   struct soap_ilist *ip;
   if (!p || !href || !*href)
     return p;
   ip = soap_lookup(soap, href); /* lookup pointer to hash table entry for string id */
   if (!ip)
   {
     ip = soap_enter(soap, href, t, n); /* new hash table entry for string id */
     if (!ip)
       return NULL;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New entry href='%s' type=%d size=%lu level=%d location=%p\n", href, t, (unsigned long)n, k, p));
   }
   else if ((ip->type != t || ip->size != n) && k == 0)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forward type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", href, ip->type, (unsigned long)ip->size, k, t, (unsigned long)n));
     (void)soap_id_nullify(soap, href);
     return NULL;
   }
   if (finsert || n < sizeof(void*))
   {
     struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(soap, sizeof(struct soap_flist));
     if (!fp)
     {
       soap->error = SOAP_EOM;
       return NULL;
     }
     if (fbase && fbase(t, ip->type) && !soap_type_punned(soap, ip))
     {
       ip->type = t;
       ip->size = n;
     }
     if ((ip->type != t || ip->size != n) && (!fbase || !fbase(ip->type, t)))
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forward type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", href, ip->type, (unsigned long)ip->size, k, t, (unsigned long)n));
       SOAP_FREE(soap, fp);
       (void)soap_id_nullify(soap, href);
       return NULL;
     }
     fp->next = ip->flist;
     fp->type = tt;
     fp->ptr = p;
     fp->level = k;
     fp->index = i;
     fp->finsert = finsert;
     ip->flist = fp;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding type=%d (target type=%d) size=%lu location=%p level=%u index=%lu href='%s'\n", t, tt, (unsigned long)n, p, k, (unsigned long)i, href));
   }
   else
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding copying address %p for type=%d href='%s'\n", p, t, href));
     *(void**)p = ip->copy;
     ip->copy = p;
   }
   ip->shaky = soap_is_shaky(soap, p);
   return p;
 }

References soap_ilist::copy, DBGLOG, soap::error, soap_flist::finsert, soap_ilist::flist, soap_flist::index, soap_flist::level, soap_flist::next, NULL, soap_flist::ptr, soap_ilist::shaky, soap_ilist::size, soap_enter(), SOAP_EOM, SOAP_FREE, soap_id_nullify(), soap_is_shaky(), soap_lookup(), SOAP_MALLOC, soap_type_punned(), TEST(), soap_flist::type, and soap_ilist::type.

Referenced by soap_in_ns1__executeCommand(), soap_in_ns1__executeCommandResponse(), soap_in_SOAP_ENV__Code(), soap_in_SOAP_ENV__Detail(), soap_in_SOAP_ENV__Fault(), soap_in_SOAP_ENV__Header(), soap_in_SOAP_ENV__Reason(), soap_inbyte(), soap_indateTime(), soap_indouble(), soap_infloat(), soap_inint(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), and soap_inunsignedShort().

◆ soap_id_lookup()

SOAP_FMAC1 void* SOAP_FMAC2 soap_id_lookup	(	struct soap *	soap,
		const char *	id,
		void **	p,
		int	t,
		size_t	n,
		unsigned int	k,
		int(*)(int, int)	fbase
	)

Definition at line 10902 of file stdsoap2.cpp.

 {
   struct soap_ilist *ip;
   if (!p || !id || !*id)
     return p;
   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
   if (!ip)
   {
     ip = soap_enter(soap, id, t, n); /* new hash table entry for string id */
     if (!ip)
       return NULL;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding first href='%s' type=%d location=%p (%u bytes) level=%u\n", id, t, (void*)p, (unsigned int)n, k));
     *p = NULL;
     if (k)
     {
       int i;
       if (k > SOAP_MAXPTRS)
         return NULL;
       ip->spine = (void**)soap_malloc(soap, SOAP_MAXPTRS * sizeof(void*));
       if (!ip->spine)
         return NULL;
       ip->spine[0] = NULL;
       for (i = 1; i < SOAP_MAXPTRS; i++)
         ip->spine[i] = &ip->spine[i - 1];
       *p = &ip->spine[k - 1];
     }
     else
     {
       ip->link = p;
       ip->shaky = soap_is_shaky(soap, (void*)p);
     }
   }
   else if (ip->type != t && (!fbase || !fbase(ip->type, t)) && (!fbase || !fbase(t, ip->type) || soap_type_punned(soap, ip)))
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup type incompatibility: ref='%s' id-type=%d ref-type=%d\n", id, ip->type, t));
     (void)soap_id_nullify(soap, id);
     return NULL;
   }
   else if (k == 0 && ip->ptr && !ip->shaky) /* when block lists are in use, ip->ptr will change */
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolved href='%s' type=%d location=%p (%u bytes) level=%u\n", id, t, ip->ptr, (unsigned int)n, k));
     *p = ip->ptr;
   }
   else
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarded href='%s' type=%d location=%p (%u bytes) level=%u\n", id, t, (void*)p, (unsigned int)n, k));
     if (fbase && fbase(t, ip->type) && !soap_type_punned(soap, ip))
     {
       ip->type = t;
       ip->size = n;
     }
     *p = NULL;
     if (k)
     {
       if (!ip->spine)
       {
         int i;
         if (k > SOAP_MAXPTRS)
           return NULL;
         ip->spine = (void**)soap_malloc(soap, SOAP_MAXPTRS * sizeof(void*));
         if (!ip->spine)
           return NULL;
         ip->spine[0] = NULL;
         for (i = 1; i < SOAP_MAXPTRS; i++)
           ip->spine[i] = &ip->spine[i - 1];
       }
       *p = &ip->spine[k - 1];
       if (ip->ptr && !ip->shaky)
         ip->spine[0] = ip->ptr;
     }
     else
     {
       void *q = ip->link;
       ip->link = p;
       ip->shaky = soap_is_shaky(soap, (void*)p);
       *p = q;
     }
   }
   return p;
 }

References DBGLOG, soap_ilist::link, NULL, soap_ilist::ptr, soap_ilist::shaky, soap_ilist::size, soap_enter(), soap_id_nullify(), soap_is_shaky(), soap_lookup(), soap_malloc(), SOAP_MAXPTRS, soap_type_punned(), soap_ilist::spine, TEST(), and soap_ilist::type.

Referenced by soap_in_PointerToSOAP_ENV__Code(), soap_in_PointerToSOAP_ENV__Detail(), soap_in_PointerToSOAP_ENV__Reason(), soap_in_PointerTostring(), soap_instring(), and soap_inwstring().

◆ soap_id_nullify()

SOAP_FMAC1 int SOAP_FMAC2 soap_id_nullify	(	struct soap *	soap,
		const char *	id
	)

Definition at line 11182 of file stdsoap2.cpp.

 {
   int i;
   for (i = 0; i < SOAP_IDHASH; i++)
   {
     struct soap_ilist *ip;
     for (ip = soap->iht[i]; ip; ip = ip->next)
     {
       void *p, *q;
       for (p = ip->link; p; p = q)
       {
         q = *(void**)p;
         *(void**)p = NULL;
       }
       ip->link = NULL;
     }
   }
   soap_strcpy(soap->id, sizeof(soap->id), id);
   return soap->error = SOAP_HREF;
 }

References soap::error, soap::id, soap::iht, soap_ilist::link, soap_ilist::next, NULL, SOAP_HREF, SOAP_IDHASH, and soap_strcpy.

Referenced by soap_id_enter(), soap_id_forward(), soap_id_lookup(), and soap_resolve().

◆ soap_id_smart()

SOAP_FMAC1 void** SOAP_FMAC2 soap_id_smart	(	struct soap *	soap,
		const char *	id,
		int	t,
		size_t	n
	)

Definition at line 11139 of file stdsoap2.cpp.

 {
   (void)soap; (void)id; (void)t; (void)n;
 #ifndef WITH_NOIDREF
   if (id && *id)
   {
     struct soap_ilist *ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
     if (!ip)
     {
       ip = soap_enter(soap, id, t, n); /* new hash table entry for string id */
       if (!ip)
         return NULL;
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New smart shared pointer entry id='%s' type=%d size=%lu smart=%p\n", id, t, (unsigned long)n, ip->smart));
     return &ip->smart;
   }
 #endif
   return NULL;
 }

References DBGLOG, NULL, soap_ilist::smart, soap_enter(), soap_lookup(), and TEST().

◆ soap_ignore()

SOAP_FMAC1 int SOAP_FMAC2 soap_ignore ( struct soap * soap )

Definition at line 15002 of file stdsoap2.cpp.

 {
   int n = 0;
   soap_wchar c;
   soap->level++;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Ignoring XML content at level=%u\n", soap->level));
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     if (!soap_string_in(soap, -1, -1, -1, NULL))
       return soap->error;
   }
   else
 #endif
   {
     for (;;)
     {
       c = soap_get(soap);
       switch (c)
       {
         case SOAP_TT:
           if (n == 0)
             goto end;
           n--;
           break;
         case SOAP_LT:
           n++;
           break;
         case '/':
           if (n > 0)
           {
             c = soap_get0(soap);
             if (c == '>')
               n--;
           }
           break;
         default:
           if ((int)c == EOF)
             return soap->error = SOAP_EOF;
       }
     }
 end:
     soap_unget(soap, c);
   }
   return soap_element_end_in(soap, NULL);
 }

References mpq::c, DBGLOG, soap::dom, soap::error, soap::level, soap::mode, NULL, soap_element_end_in(), SOAP_EOF, soap_get(), soap_get0, SOAP_LT, soap_string_in(), SOAP_TT, soap_unget, SOAP_XML_DOM, and TEST().

Referenced by soap_ignore_element().

◆ soap_inbyte()

SOAP_FMAC1 char* SOAP_FMAC2 soap_inbyte	(	struct soap *	soap,
		const char *	tag,
		char *	p,
		const char *	type,
		int	t
	)

Definition at line 16433 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":byte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (char*)soap_id_enter(soap, soap->id, p, t, sizeof(char), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2byte(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (char*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(char), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2byte(), SOAP_TYPE, soap_value(), and soap::type.

Referenced by soap_in_byte().

◆ soap_indateTime()

SOAP_FMAC1 time_t* SOAP_FMAC2 soap_indateTime	(	struct soap *	soap,
		const char *	tag,
		time_t *	p,
		const char *	type,
		int	t
	)

Definition at line 18822 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":dateTime"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
   p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2dateTime(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(time_t), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2dateTime(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_indouble()

SOAP_FMAC1 double* SOAP_FMAC2 soap_indouble	(	struct soap *	soap,
		const char *	tag,
		double *	p,
		const char *	type,
		int	t
	)

Definition at line 16887 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type != '\0' && soap_isnumeric(soap, type))
     return NULL;
 #else
   (void)type;
 #endif
   p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2double(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (double*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(double), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_isnumeric(), soap_s2double(), soap_value(), and soap::type.

◆ soap_infloat()

SOAP_FMAC1 float* SOAP_FMAC2 soap_infloat	(	struct soap *	soap,
		const char *	tag,
		float *	p,
		const char *	type,
		int	t
	)

Definition at line 16734 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type != '\0' && soap_isnumeric(soap, type))
     return NULL;
 #else
   (void)type;
 #endif
   p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2float(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (float*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(float), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_isnumeric(), soap_s2float(), soap_value(), and soap::type.

◆ soap_inint()

SOAP_FMAC1 int* SOAP_FMAC2 soap_inint	(	struct soap *	soap,
		const char *	tag,
		int *	p,
		const char *	type,
		int	t
	)

Definition at line 16152 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":int")
    && soap_match_tag(soap, soap->type, ":short")
    && soap_match_tag(soap, soap->type, ":byte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2int(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (int*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(int), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2int(), SOAP_TYPE, soap_value(), and soap::type.

Referenced by soap_in_int().

◆ soap_init()

SOAP_FMAC1 void SOAP_FMAC2 soap_versioning() soap_init	(	struct soap *	soap,
		soap_mode	imode,
		soap_mode	omode
	)

Definition at line 12050 of file stdsoap2.cpp.

 {
   size_t i;
   soap->state = SOAP_INIT;
 #ifdef SOAP_MEM_DEBUG
   soap_init_mht(soap);
 #endif
 #ifdef SOAP_DEBUG
   soap_init_logs(soap);
 #endif
 #ifdef TANDEM_NONSTOP
   soap_set_test_logfile(soap, "TESTLOG");
   soap_set_sent_logfile(soap, "SENTLOG");
   soap_set_recv_logfile(soap, "RECVLOG");
 #else
   soap_set_test_logfile(soap, "TEST.log");
   soap_set_sent_logfile(soap, "SENT.log");
   soap_set_recv_logfile(soap, "RECV.log");
 #endif
 #ifdef WITH_SELF_PIPE
   pipe(soap->pipe_fd);
   SOAP_SOCKNONBLOCK(soap->pipe_fd[0])
   SOAP_SOCKNONBLOCK(soap->pipe_fd[1])
 #endif
   soap->version = 0;
   soap->imode = imode;
   soap->omode = omode;
   soap->mode = imode;
   soap->plugins = NULL;
   soap->user = NULL;
   for (i = 0; i < sizeof(soap->data)/sizeof(*soap->data); i++)
     soap->data[i] = NULL;
   soap->bearer = NULL;
   soap->userid = NULL;
   soap->passwd = NULL;
   soap->authrealm = NULL;
 #ifdef WITH_NTLM
   soap->ntlm_challenge = NULL;
 #endif
 #ifndef WITH_NOHTTP
   soap->fpost = http_post;
   soap->fget = http_get;
   soap->fput = http_put;
   soap->fpatch = http_patch;
   soap->fdel = http_del;
   soap->fopt = http_200;
   soap->fhead = http_200;
   soap->fform = NULL;
   soap->fposthdr = http_post_header;
   soap->fresponse = http_response;
   soap->fparse = http_parse;
   soap->fparsehdr = http_parse_header;
 #endif
   soap->fheader = NULL;
   soap->fconnect = NULL;
   soap->fdisconnect = NULL;
 #ifndef WITH_NOIO
   soap->ipv6_multicast_if = 0; /* in_addr_t value */
   soap->ipv4_multicast_if = NULL; /* points to struct in_addr or in_addr_t */
   soap->ipv4_multicast_ttl = 0; /* 0: use default */
   soap->client_addr = NULL; /* client address (IPv4 or IPv6 or host name) to bind before connect, NULL for none */
   soap->client_addr_ipv6 = NULL; /* client address IPv6 or host name to bind before connect, NULL for none */
   soap->client_port = -1; /* client port to bind before connect, -1 for none */
   soap->client_interface = NULL; /* client interface address, NULL for none */
 #ifndef WITH_IPV6
   soap->fresolve = tcp_gethost;
 #else
   soap->fresolve = NULL;
 #endif
   soap->faccept = tcp_accept;
   soap->fopen = tcp_connect;
   soap->fclose = tcp_disconnect;
   soap->fclosesocket = tcp_closesocket;
   soap->fshutdownsocket = tcp_shutdownsocket;
   soap->fsend = fsend;
   soap->frecv = frecv;
   soap->fpoll = soap_poll;
 #else
   soap->fopen = NULL;
   soap->fclose = NULL;
   soap->fpoll = NULL;
 #endif
   soap->fseterror = NULL;
   soap->fignore = NULL;
   soap->fserveloop = NULL;
   soap->fplugin = fplugin;
 #ifndef WITH_LEANER
   soap->fsvalidate = NULL;
   soap->fwvalidate = NULL;
   soap->feltbegin = NULL;
   soap->feltendin = NULL;
   soap->feltbegout = NULL;
   soap->feltendout = NULL;
   soap->fprepareinitsend = NULL;
   soap->fprepareinitrecv = NULL;
   soap->fpreparesend = NULL;
   soap->fpreparerecv = NULL;
   soap->fpreparefinalsend = NULL;
   soap->fpreparefinalrecv = NULL;
   soap->ffiltersend = NULL;
   soap->ffilterrecv = NULL;
   soap->fdimereadopen = NULL;
   soap->fdimewriteopen = NULL;
   soap->fdimereadclose = NULL;
   soap->fdimewriteclose = NULL;
   soap->fdimeread = NULL;
   soap->fdimewrite = NULL;
   soap->fmimereadopen = NULL;
   soap->fmimewriteopen = NULL;
   soap->fmimereadclose = NULL;
   soap->fmimewriteclose = NULL;
   soap->fmimeread = NULL;
   soap->fmimewrite = NULL;
 #endif
   soap->float_format = "%.9G"; /* Alternative: use "%G" */
   soap->double_format = "%.17lG"; /* Alternative: use "%lG" */
   soap->long_double_format = NULL; /* Defined in custom serializer custom/long_double.c */
   soap->dime_id_format = "cid:id%d"; /* default DIME id format for int id index */
   soap->recv_maxlength = 0x7FFFFFFF; /* default max length of messages received (2GB) */
   soap->recv_timeout = 0;
   soap->send_timeout = 0;
   soap->transfer_timeout = 0;
   soap->connect_timeout = 0;
   soap->accept_timeout = 0;
   soap->socket_flags = 0;
   soap->connect_flags = 0;
   soap->connect_retry = 0;
   soap->bind_flags = 0;
 #ifdef WITH_IPV6_V6ONLY
   soap->bind_inet6 = 1;
   soap->bind_v6only = 1;
 #else
   soap->bind_inet6 = 0;
   soap->bind_v6only = 0;
 #endif
   soap->accept_flags = 0;
 #ifdef WIN32
   soap->sndbuf = SOAP_BUFLEN + 1; /* this size speeds up windows xfer */
   soap->rcvbuf = SOAP_BUFLEN + 1;
 #else
   soap->sndbuf = SOAP_BUFLEN;
   soap->rcvbuf = SOAP_BUFLEN;
 #endif
   soap->linger_time = 0;
   soap->maxlevel = SOAP_MAXLEVEL;
   soap->maxlength = SOAP_MAXLENGTH;
   soap->maxoccurs = SOAP_MAXOCCURS;
   soap->http_version = "1.1";
   soap->proxy_http_version = "1.0";
   soap->http_content = NULL;
   soap->http_extra_header = NULL;
   soap->actor = NULL;
   soap->lang = "en";
   soap->keep_alive = 0;
   soap->tcp_keep_alive = 0;
   soap->tcp_keep_idle = 0;
   soap->tcp_keep_intvl = 0;
   soap->tcp_keep_cnt = 0;
   soap->max_keep_alive = SOAP_MAXKEEPALIVE;
   soap->ip = 0;
   soap->ip6[0] = 0;
   soap->ip6[1] = 0;
   soap->ip6[2] = 0;
   soap->ip6[3] = 0;
   soap->labbuf = NULL;
   soap->lablen = 0;
   soap->labidx = 0;
   soap->encodingStyle = NULL;
 #ifndef WITH_NONAMESPACES
   soap->namespaces = namespaces;
 #else
   soap->namespaces = NULL;
 #endif
   soap->local_namespaces = NULL;
   soap->nlist = NULL;
   soap->blist = NULL;
   soap->clist = NULL;
   soap->alist = NULL;
   soap->shaky = 0;
   soap->attributes = NULL;
   soap->header = NULL;
   soap->fault = NULL;
   soap->master = SOAP_INVALID_SOCKET;
   soap->socket = SOAP_INVALID_SOCKET;
   soap->sendsk = SOAP_INVALID_SOCKET;
   soap->recvsk = SOAP_INVALID_SOCKET;
   soap->os = NULL;
   soap->is = NULL;
 #ifndef WITH_LEANER
   soap->dom = NULL;
   soap->dime.list = NULL;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
   soap->mime.list = NULL;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->mime.boundary = NULL;
   soap->mime.start = NULL;
   soap->xlist = NULL;
 #endif
 #ifndef UNDER_CE
   soap->recvfd = 0;
   soap->sendfd = 1;
 #else
   soap->recvfd = stdin;
   soap->sendfd = stdout;
 #endif
   soap->tag[0] = '\0';
   soap->id[0] = '\0';
   soap->href[0] = '\0';
   soap->type[0] = '\0';
   soap->arrayType[0] = '\0';
   soap->arraySize[0] = '\0';
   soap->arrayOffset[0] = '\0';
   soap->endpoint[0] = '\0';
   soap->host[0] = '\0';
   soap->path[0] = '\0';
   soap->port = 0;
   soap->override_host = NULL;
   soap->override_port = 0;
   soap->action = NULL;
   soap->proxy_host = NULL;
   soap->proxy_port = 8080;
   soap->proxy_userid = NULL;
   soap->proxy_passwd = NULL;
   soap->proxy_from = NULL;
   soap->origin = NULL;
   soap->cors_origin = NULL;
   soap->cors_allow = "*";
   soap->cors_method = NULL;
   soap->cors_header = NULL;
   soap->cors_methods = NULL;
   soap->cors_headers = NULL;
   soap->x_frame_options = "SAMEORIGIN";
   soap->prolog = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
   soap->zlib_state = SOAP_ZLIB_NONE;
   soap->zlib_in = SOAP_ZLIB_NONE;
   soap->zlib_out = SOAP_ZLIB_NONE;
   soap->d_stream = NULL;
   soap->z_buf = NULL;
   soap->z_level = 6;
   soap->z_dict = NULL;
   soap->z_dict_len = 0;
 #ifndef WITH_LEAN
   soap->wsuid = NULL;
   soap->c14nexclude = NULL;
   soap->c14ninclude = NULL;
   soap->cookies = NULL;
   soap->cookie_domain = NULL;
   soap->cookie_path = NULL;
   soap->cookie_max = 32;
 #endif
 #ifdef WMW_RPM_IO
   soap->rpmreqid = NULL;
 #endif
 #ifndef WITH_NOIDREF
   soap_init_iht(soap);
 #endif
   soap_init_pht(soap);
 #ifdef WITH_OPENSSL
   if (!soap_ssl_init_done)
     soap_ssl_init();
   soap->fsslauth = ssl_auth_init;
   soap->fsslverify = NULL;
   soap->bio = NULL;
   soap->ssl = NULL;
   soap->ctx = NULL;
   soap->session = NULL;
   soap->session_host[0] = '\0';
   soap->session_port = 443;
   soap->ssl_flags = SOAP_SSL_DEFAULT;
   soap->keyfile = NULL;
   soap->keyid = NULL;
   soap->password = NULL;
   soap->cafile = NULL;
   soap->capath = NULL;
   soap->crlfile = NULL;
   soap->dhfile = NULL;
   soap->randfile = NULL;
 #endif
 #ifdef WITH_GNUTLS
   if (!soap_ssl_init_done)
     soap_ssl_init();
   soap->fsslauth = ssl_auth_init;
   soap->fsslverify = NULL;
   soap->xcred = NULL;
   soap->acred = NULL;
   soap->cache = NULL;
   soap->session = NULL;
   soap->ssl_flags = SOAP_SSL_DEFAULT;
   soap->keyfile = NULL;
   soap->keyid = NULL;
   soap->password = NULL;
   soap->cafile = NULL;
   soap->capath = NULL;
   soap->crlfile = NULL;
   soap->dh_params = NULL;
   soap->rsa_params = NULL;
 #endif
 #ifdef WITH_SYSTEMSSL
   soap->fsslauth = ssl_auth_init;
   soap->fsslverify = NULL;
   soap->bio = NULL;
   soap->ssl = (gsk_handle)NULL;
   soap->ctx = (gsk_handle)NULL;
   soap->session = NULL;
   soap->ssl_flags = SOAP_SSL_DEFAULT;
   soap->keyfile = NULL;
   soap->keyid = NULL;
   soap->password = NULL;
   soap->cafile = NULL;
   soap->capath = NULL;
   soap->crlfile = NULL;
   soap->dhfile = NULL;
   soap->randfile = NULL;
 #endif
   soap->c_locale = NULL;
   soap->buflen = 0;
   soap->bufidx = 0;
 #ifndef WITH_LEANER
   soap->dime.chunksize = 0;
   soap->dime.buflen = 0;
 #endif
   soap->other = 0;
   soap->root = -1;
   soap->null = 0;
   soap->position = 0;
   soap->encoding = 0;
   soap->mustUnderstand = 0;
   soap->ns = 0;
   soap->part = SOAP_END;
   soap->event = 0;
   soap->evlev = 0;
   soap->alloced = 0;
   soap->count = 0;
   soap->length = 0;
   soap->cdata = 0;
   soap->peeked = 0;
   soap->ahead = 0;
   soap->idnum = 0;
   soap->level = 0;
   soap->status = 0;
   soap->error = SOAP_OK;
   soap->errmode = 0;
   soap->errnum = 0;
 }

References soap::accept_flags, soap::accept_timeout, soap::action, soap::actor, soap::ahead, soap::alist, soap::alloced, soap::arrayOffset, soap::arraySize, soap::arrayType, soap::attributes, soap::authrealm, soap::bearer, soap::bind_flags, soap::bind_inet6, soap::bind_v6only, soap::bio, soap::blist, soap_mime::boundary, soap::bufidx, soap_dime::buflen, soap::buflen, soap::c14nexclude, soap::c14ninclude, soap::c_locale, soap::cafile, soap::capath, soap::cdata, soap_dime::chunksize, soap::client_addr, soap::client_addr_ipv6, soap::client_interface, soap::client_port, soap::clist, soap::connect_flags, soap::connect_retry, soap::connect_timeout, soap::cookie_domain, soap::cookie_max, soap::cookie_path, soap::cookies, soap::cors_allow, soap::cors_header, soap::cors_headers, soap::cors_method, soap::cors_methods, soap::cors_origin, soap::count, soap::crlfile, soap::ctx, soap::d_stream, soap::data, soap::dh_params, soap::dime, soap::dime_id_format, soap::dom, soap::double_format, soap::encoding, soap::encodingStyle, endif(), soap::endpoint, soap::errmode, soap::errnum, soap::error, soap::event, soap::evlev, soap::faccept, soap::fault, soap::fclose, soap::fclosesocket, soap::fconnect, soap::fdel, soap::fdimeread, soap::fdimereadclose, soap::fdimereadopen, soap::fdimewrite, soap::fdimewriteclose, soap::fdimewriteopen, soap::fdisconnect, soap::feltbegin, soap::feltbegout, soap::feltendin, soap::feltendout, soap::ffilterrecv, soap::ffiltersend, soap::fform, soap::fget, soap::fhead, soap::fheader, soap::fignore, soap_dime::first, soap_mime::first, soap::float_format, soap::fmimeread, soap::fmimereadclose, soap::fmimereadopen, soap::fmimewrite, soap::fmimewriteclose, soap::fmimewriteopen, soap::fopen, soap::fopt, soap::fparse, soap::fparsehdr, soap::fpatch, fplugin(), soap::fplugin, soap::fpoll, soap::fpost, soap::fposthdr, soap::fpreparefinalrecv, soap::fpreparefinalsend, soap::fprepareinitrecv, soap::fprepareinitsend, soap::fpreparerecv, soap::fpreparesend, soap::fput, frecv(), soap::frecv, soap::fresolve, soap::fresponse, fsend(), soap::fsend, soap::fserveloop, soap::fseterror, soap::fshutdownsocket, soap::fsslauth, soap::fsslverify, soap::fsvalidate, soap::fwvalidate, soap::header, soap::host, soap::href, http_200(), soap::http_content, http_del(), soap::http_extra_header, http_get(), http_parse(), http_parse_header(), http_patch(), http_post(), http_post_header(), http_put(), http_response(), soap::http_version, soap::id, soap::idnum, soap::imode, soap::ip, soap::ip6, soap::ipv4_multicast_if, soap::ipv4_multicast_ttl, soap::ipv6_multicast_if, soap::is, soap::keep_alive, soap::keyfile, soap::keyid, soap::labbuf, soap::labidx, soap::lablen, soap::lang, soap_dime::last, soap_mime::last, soap::length, soap::level, soap::linger_time, soap_dime::list, soap_mime::list, soap::local_namespaces, soap::long_double_format, soap::master, soap::max_keep_alive, soap::maxlength, soap::maxlevel, soap::maxoccurs, soap::mime, soap::mode, soap::mustUnderstand, soap::namespaces, namespaces, soap::nlist, soap::ns, soap::ntlm_challenge, soap::null, NULL, soap::omode, soap::origin, soap::os, soap::other, soap::override_host, soap::override_port, soap::part, soap::passwd, soap::password, soap::path, soap::peeked, soap::plugins, soap::port, soap::position, soap::prolog, soap::proxy_from, soap::proxy_host, soap::proxy_http_version, soap::proxy_passwd, soap::proxy_port, soap::proxy_userid, soap::rcvbuf, soap::recv_maxlength, soap::recv_timeout, soap::recvfd, soap::recvsk, soap::root, soap::rsa_params, soap::send_timeout, soap::sendfd, soap::sendsk, soap::session, soap::session_host, soap::session_port, soap::shaky, soap::sndbuf, SOAP_BUFLEN, SOAP_END, SOAP_INIT, soap_init_iht(), soap_init_pht(), SOAP_INVALID_SOCKET, SOAP_MAXKEEPALIVE, SOAP_MAXLENGTH, SOAP_MAXLEVEL, SOAP_MAXOCCURS, SOAP_OK, soap_poll(), soap_set_recv_logfile(), soap_set_sent_logfile(), soap_set_test_logfile(), SOAP_SOCKNONBLOCK, SOAP_SSL_DEFAULT, soap_ssl_init(), SOAP_ZLIB_NONE, soap::socket, soap::socket_flags, soap::ssl, soap::ssl_flags, soap_mime::start, soap::state, soap::status, soap::tag, tcp_accept(), tcp_closesocket(), tcp_connect(), tcp_disconnect(), tcp_gethost(), soap::tcp_keep_alive, soap::tcp_keep_cnt, soap::tcp_keep_idle, soap::tcp_keep_intvl, tcp_shutdownsocket(), soap::transfer_timeout, soap::type, soap::user, soap::userid, soap::version, soap::wsuid, soap::x_frame_options, soap::xlist, soap::z_buf, soap::z_dict, soap::z_dict_len, soap::z_level, soap::zlib_in, soap::zlib_out, and soap::zlib_state.

Referenced by soap_initialize(), and soap_new().

◆ soap_initialize()

SOAP_FMAC1 void SOAP_FMAC2 soap_initialize ( struct soap * soap )

Definition at line 12040 of file stdsoap2.cpp.

 {
   soap_versioning(soap_init)(soap, SOAP_IO_DEFAULT, SOAP_IO_DEFAULT);
 }

References soap, soap_init(), SOAP_IO_DEFAULT, and soap_versioning.

◆ soap_inliteral()

SOAP_FMAC1 char** SOAP_FMAC2 soap_inliteral	(	struct soap *	soap,
		const char *	tag,
		char **	p
	)

Definition at line 18876 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 1, NULL))
   {
     if (soap->error != SOAP_NO_TAG || soap_peek(soap) == SOAP_TT)
       return NULL;
     soap->error = SOAP_OK;
   }
   if (!p)
   {
     p = (char**)soap_malloc(soap, sizeof(char*));
     if (!p)
       return NULL;
   }
   if (soap->body || (tag && *tag == '-'))
   {
     if (tag && *tag != '-')
       *p = soap_string_in(soap, -1, -1, -1, NULL);
     else
       *p = soap_string_in(soap, 0, -1, -1, NULL);
     if (!*p)
       return NULL;
     if (!**p && tag && *tag == '-')
     {
       soap->error = SOAP_NO_TAG;
       return NULL;
     }
   }
   else if (soap->null)
   {
     *p = NULL;
   }
   else
   {
     *p = soap_strdup(soap, SOAP_STR_EOS);
   }
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
   return p;
 }

References soap::body, soap::error, soap::null, NULL, soap_element_begin_in(), soap_element_end_in(), soap_malloc(), SOAP_NO_TAG, SOAP_OK, soap_peek, SOAP_STR_EOS, soap_strdup(), soap_string_in(), and SOAP_TT.

Referenced by soap_in_SOAP_ENV__Detail(), and soap_recv_fault().

◆ soap_inlong()

SOAP_FMAC1 long* SOAP_FMAC2 soap_inlong	(	struct soap *	soap,
		const char *	tag,
		long *	p,
		const char *	type,
		int	t
	)

Definition at line 16247 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":int")
    && soap_match_tag(soap, soap->type, ":short")
    && soap_match_tag(soap, soap->type, ":byte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2long(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (long*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(long), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2long(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inLONG64()

SOAP_FMAC1 LONG64* SOAP_FMAC2 soap_inLONG64	(	struct soap *	soap,
		const char *	tag,
		LONG64 *	p,
		const char *	type,
		int	t
	)

Definition at line 16342 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":integer")
    && soap_match_tag(soap, soap->type, ":positiveInteger")
    && soap_match_tag(soap, soap->type, ":negativeInteger")
    && soap_match_tag(soap, soap->type, ":nonPositiveInteger")
    && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
    && soap_match_tag(soap, soap->type, ":long")
    && soap_match_tag(soap, soap->type, ":int")
    && soap_match_tag(soap, soap->type, ":short")
    && soap_match_tag(soap, soap->type, ":byte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (LONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(LONG64), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2LONG64(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (LONG64*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(LONG64), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, LONG64, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2LONG64(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inshort()

SOAP_FMAC1 short* SOAP_FMAC2 soap_inshort	(	struct soap *	soap,
		const char *	tag,
		short *	p,
		const char *	type,
		int	t
	)

Definition at line 16516 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":short")
    && soap_match_tag(soap, soap->type, ":byte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (short*)soap_id_enter(soap, soap->id, p, t, sizeof(short), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2short(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (short*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(short), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2short(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_instring()

SOAP_FMAC1 char** SOAP_FMAC2 soap_instring	(	struct soap *	soap,
		const char *	tag,
		char **	p,
		const char *	type,
		int	t,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 18300 of file stdsoap2.cpp.

 {
   (void)type;
   if (soap_element_begin_in(soap, tag, 1, NULL))
   {
     if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
       return NULL;
     soap->error = SOAP_OK;
   }
   if (!p)
   {
     p = (char**)soap_malloc(soap, sizeof(char*));
     if (!p)
       return NULL;
   }
   if (soap->null)
   {
     *p = NULL;
   }
   else if (soap->body)
   {
     *p = soap_string_in(soap, flag, minlen, maxlen, pattern);
     if (!*p || !(char*)soap_id_enter(soap, soap->id, *p, t, sizeof(char*), NULL, NULL, NULL, NULL))
       return NULL;
     if (!**p && tag && *tag == '-')
     {
       soap->error = SOAP_NO_TAG;
       return NULL;
     }
   }
   else if (tag && *tag == '-')
   {
     soap->error = SOAP_NO_TAG;
     return NULL;
   }
   else if (*soap->href != '#')
   {
     if (minlen > 0)
     {
       soap->error = SOAP_LENGTH;
       return NULL;
     }
     *p = soap_strdup(soap, SOAP_STR_EOS);
     if (!*p)
       return NULL;
   }
   if (*soap->href == '#')
     p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, soap::null, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_lookup(), SOAP_LENGTH, soap_malloc(), SOAP_NO_TAG, SOAP_OK, SOAP_STR_EOS, soap_strdup(), and soap_string_in().

Referenced by soap_check_result(), soap_in__QName(), soap_in_string(), and soap_recv_fault().

◆ soap_int2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_int2s	(	struct soap *	soap,
		int	n
	)

Definition at line 16094 of file stdsoap2.cpp.

 {
   return soap_long2s(soap, (long)n);
 }

References soap_long2s().

Referenced by soap_bind(), and tcp_connect().

◆ soap_inULONG64()

SOAP_FMAC1 ULONG64* SOAP_FMAC2 soap_inULONG64	(	struct soap *	soap,
		const char *	tag,
		ULONG64 *	p,
		const char *	type,
		int	t
	)

Definition at line 17340 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":positiveInteger")
    && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
    && soap_match_tag(soap, soap->type, ":unsignedLong")
    && soap_match_tag(soap, soap->type, ":unsignedInt")
    && soap_match_tag(soap, soap->type, ":unsignedShort")
    && soap_match_tag(soap, soap->type, ":unsignedByte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (ULONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(ULONG64), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2ULONG64(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (ULONG64*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(ULONG64), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2ULONG64(), SOAP_TYPE, soap_value(), soap::type, and ULONG64.

◆ soap_inunsignedByte()

SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_inunsignedByte	(	struct soap *	soap,
		const char *	tag,
		unsigned char *	p,
		const char *	type,
		int	t
	)

Definition at line 16964 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":unsignedByte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2unsignedByte(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(unsigned char), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2unsignedByte(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inunsignedInt()

SOAP_FMAC1 unsigned int* SOAP_FMAC2 soap_inunsignedInt	(	struct soap *	soap,
		const char *	tag,
		unsigned int *	p,
		const char *	type,
		int	t
	)

Definition at line 17144 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":unsignedInt")
    && soap_match_tag(soap, soap->type, ":unsignedShort")
    && soap_match_tag(soap, soap->type, ":unsignedByte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2unsignedInt(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(unsigned int), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2unsignedInt(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inunsignedLong()

SOAP_FMAC1 unsigned long* SOAP_FMAC2 soap_inunsignedLong	(	struct soap *	soap,
		const char *	tag,
		unsigned long *	p,
		const char *	type,
		int	t
	)

Definition at line 17243 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":unsignedInt")
    && soap_match_tag(soap, soap->type, ":unsignedShort")
    && soap_match_tag(soap, soap->type, ":unsignedByte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2unsignedLong(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(unsigned long), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2unsignedLong(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inunsignedShort()

SOAP_FMAC1 unsigned short* SOAP_FMAC2 soap_inunsignedShort	(	struct soap *	soap,
		const char *	tag,
		unsigned short *	p,
		const char *	type,
		int	t
	)

Definition at line 17047 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
   if (*soap->type
    && soap_match_tag(soap, soap->type, type)
    && soap_match_tag(soap, soap->type, ":unsignedShort")
    && soap_match_tag(soap, soap->type, ":unsignedByte"))
   {
     soap->error = SOAP_TYPE;
     soap_revert(soap);
     return NULL;
   }
 #else
   (void)type;
 #endif
   p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), NULL, NULL, NULL, NULL);
   if (!p)
     return NULL;
   if (*soap->href != '#')
   {
     int err = soap_s2unsignedShort(soap, soap_value(soap), p);
     if ((soap->body && soap_element_end_in(soap, tag)) || err)
       return NULL;
   }
   else
   {
     p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, t, sizeof(unsigned short), 0, NULL, NULL);
     if (soap->body && soap_element_end_in(soap, tag))
       return NULL;
   }
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_forward(), soap_match_tag(), soap_revert(), soap_s2unsignedShort(), SOAP_TYPE, soap_value(), and soap::type.

◆ soap_inwliteral()

SOAP_FMAC1 wchar_t** SOAP_FMAC2 soap_inwliteral	(	struct soap *	soap,
		const char *	tag,
		wchar_t **	p
	)

Definition at line 18950 of file stdsoap2.cpp.

 {
   if (soap_element_begin_in(soap, tag, 1, NULL))
   {
     if (soap->error != SOAP_NO_TAG || soap_peek(soap) == SOAP_TT)
       return NULL;
     soap->error = SOAP_OK;
   }
   if (!p)
   {
     p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*));
     if (!p)
       return NULL;
   }
   if (soap->body)
   {
     if (tag && *tag != '-')
       *p = soap_wstring_in(soap, -1, -1, -1, NULL);
     else
       *p = soap_wstring_in(soap, 0, -1, -1, NULL);
     if (!*p)
       return NULL;
     if (!**p && tag && *tag == '-')
     {
       soap->error = SOAP_NO_TAG;
       return NULL;
     }
   }
   else if (tag && *tag == '-')
   {
     soap->error = SOAP_NO_TAG;
     return NULL;
   }
   else if (soap->null)
   {
     *p = NULL;
   }
   else
   {
     *p = soap_wstrdup(soap, L"");
   }
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
   return p;
 }

References soap::body, soap::error, soap::null, NULL, soap_element_begin_in(), soap_element_end_in(), soap_malloc(), SOAP_NO_TAG, SOAP_OK, soap_peek, SOAP_TT, soap_wstrdup(), and soap_wstring_in().

◆ soap_inwstring()

SOAP_FMAC1 wchar_t** SOAP_FMAC2 soap_inwstring	(	struct soap *	soap,
		const char *	tag,
		wchar_t **	p,
		const char *	type,
		int	t,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 18380 of file stdsoap2.cpp.

 {
   (void)type;
   if (soap_element_begin_in(soap, tag, 1, NULL))
   {
     if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
       return NULL;
     soap->error = SOAP_OK;
   }
   if (!p)
   {
     p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*));
     if (!p)
       return NULL;
   }
   if (soap->null)
   {
     *p = NULL;
   }
   else if (soap->body)
   {
     *p = soap_wstring_in(soap, flag, minlen, maxlen, pattern);
     if (!*p || !(wchar_t*)soap_id_enter(soap, soap->id, *p, t, sizeof(wchar_t*), NULL, NULL, NULL, NULL))
       return NULL;
     if (!**p && tag && *tag == '-')
     {
       soap->error = SOAP_NO_TAG;
       return NULL;
     }
   }
   else if (tag && *tag == '-')
   {
     soap->error = SOAP_NO_TAG;
     return NULL;
   }
   else if (*soap->href != '#')
   {
     if (minlen > 0)
     {
       soap->error = SOAP_LENGTH;
       return NULL;
     }
     *p = soap_wstrdup(soap, L"");
   }
   if (*soap->href == '#')
     p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
   return p;
 }

References soap::body, soap::error, soap::href, soap::id, soap::null, NULL, soap_element_begin_in(), soap_element_end_in(), soap_id_enter(), soap_id_lookup(), SOAP_LENGTH, soap_malloc(), SOAP_NO_TAG, SOAP_OK, soap_wstrdup(), and soap_wstring_in().

◆ soap_is_embedded()

SOAP_FMAC1 int SOAP_FMAC2 soap_is_embedded	(	struct soap *	soap,
		struct soap_plist *	pp
	)

Definition at line 10159 of file stdsoap2.cpp.

 {
   if (!pp)
     return 0;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Is embedded? %d %d\n", (int)pp->mark1, (int)pp->mark2));
   if (soap->version == 1 && soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER)
   {
     if ((soap->mode & SOAP_IO_LENGTH))
       return pp->mark1 != 0;
     return pp->mark2 != 0;
   }
   if ((soap->mode & SOAP_IO_LENGTH))
     return pp->mark1 == 1;
   return pp->mark2 == 1;
 }

References DBGLOG, soap::encodingStyle, soap_plist::mark1, soap_plist::mark2, soap::mode, soap::omode, soap::part, SOAP_IN_HEADER, SOAP_IO_LENGTH, SOAP_XML_GRAPH, TEST(), and soap::version.

Referenced by soap_element_id(), and soap_embed().

◆ soap_is_single()

SOAP_FMAC1 int SOAP_FMAC2 soap_is_single	(	struct soap *	soap,
		struct soap_plist *	pp
	)

Definition at line 10182 of file stdsoap2.cpp.

 {
   if (soap->part == SOAP_IN_HEADER)
     return 1;
   if (!pp)
     return 0;
   if ((soap->mode & SOAP_IO_LENGTH))
     return pp->mark1 == 0;
   return pp->mark2 == 0;
 }

References soap_plist::mark1, soap_plist::mark2, soap::mode, soap::part, SOAP_IN_HEADER, and SOAP_IO_LENGTH.

Referenced by soap_element_id(), and soap_embed().

◆ soap_link()

SOAP_FMAC1 struct soap_clist* SOAP_FMAC2 soap_link	(	struct soap *	soap,
		int	t,
		int	n,
		int()(struct soap , struct soap_clist *)	fdelete
	)

Definition at line 10768 of file stdsoap2.cpp.

 {
   struct soap_clist *cp = NULL;
   if (soap)
   {
     if (n != SOAP_NO_LINK_TO_DELETE)
     {
       cp = (struct soap_clist*)SOAP_MALLOC(soap, sizeof(struct soap_clist));
       if (!cp)
       {
         soap->error = SOAP_EOM;
       }
       else
       {
         cp->next = soap->clist;
         cp->type = t;
         cp->size = n;
         cp->ptr = NULL;
         cp->fdelete = fdelete;
         soap->clist = cp;
       }
     }
     soap->alloced = t;
   }
   return cp;
 }

References soap::alloced, soap::clist, soap::error, soap_clist::fdelete, soap_clist::next, NULL, soap_clist::ptr, soap_clist::size, SOAP_EOM, SOAP_MALLOC, SOAP_NO_LINK_TO_DELETE, and soap_clist::type.

◆ soap_long2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_long2s	(	struct soap *	soap,
		long	n
	)

Definition at line 16193 of file stdsoap2.cpp.

 {
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), "%ld", n);
   return soap->tmpbuf;
 }

References SOAP_SNPRINTF, and soap::tmpbuf.

Referenced by soap_byte2s(), soap_int2s(), soap_outbyte(), soap_outint(), soap_outlong(), soap_outshort(), and soap_short2s().

◆ soap_LONG642s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_LONG642s	(	struct soap *	soap,
		LONG64	n
	)

Definition at line 16288 of file stdsoap2.cpp.

 {
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), SOAP_LONG_FORMAT, n);
   return soap->tmpbuf;
 }

References SOAP_LONG_FORMAT, SOAP_SNPRINTF, and soap::tmpbuf.

Referenced by soap_outLONG64().

◆ soap_lookup()

SOAP_FMAC1 struct soap_ilist* SOAP_FMAC2 soap_lookup	(	struct soap *	soap,
		const char *	id
	)

Definition at line 10353 of file stdsoap2.cpp.

 {
   struct soap_ilist *ip = NULL;
   for (ip = soap->iht[soap_hash(id)]; ip; ip = ip->next)
     if (!strcmp(ip->id, id))
       return ip;
   return NULL;
 }

References soap_ilist::id, soap::iht, soap_ilist::next, NULL, and soap_hash().

Referenced by soap_id_enter(), soap_id_forward(), soap_id_lookup(), soap_id_smart(), and soap_lookup_type().

◆ soap_lookup_ns()

SOAP_FMAC1 struct soap_nlist* SOAP_FMAC2 soap_lookup_ns	(	struct soap *	soap,
		const char *	tag,
		size_t	n
	)

Definition at line 12644 of file stdsoap2.cpp.

 {
   struct soap_nlist *np;
   for (np = soap->nlist; np; np = np->next)
     if (!strncmp(np->id, tag, n) && !np->id[n])
       return np;
   return NULL;
 }

References soap_nlist::id, soap_nlist::next, soap::nlist, and NULL.

Referenced by soap_set_attr(), and soap_utilize_ns().

◆ soap_lookup_plugin()

SOAP_FMAC1 void* SOAP_FMAC2 soap_lookup_plugin	(	struct soap *	soap,
		const char *	id
	)

Definition at line 22904 of file stdsoap2.cpp.

 {
   return soap->fplugin(soap, id);
 }

References soap::fplugin.

Referenced by soap_register_plugin_arg().

◆ soap_lookup_type()

SOAP_FMAC1 int SOAP_FMAC2 soap_lookup_type	(	struct soap *	soap,
		const char *	id
	)

Definition at line 10839 of file stdsoap2.cpp.

 {
   struct soap_ilist *ip;
   if (id && *id)
   {
     ip = soap_lookup(soap, id);
     if (ip)
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup id='%s' type=%d\n", id, ip->type));
       return ip->type;
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "lookup type id='%s' NOT FOUND! Need to get it from xsi:type\n", id));
   return 0;
 }

References DBGLOG, soap_lookup(), TEST(), and soap_ilist::type.

Referenced by soap_getelement().

◆ soap_malloc()

SOAP_FMAC1 void* SOAP_FMAC2 soap_malloc	(	struct soap *	soap,
		size_t	n
	)

Definition at line 10401 of file stdsoap2.cpp.

 {
   char *p;
   size_t k = n;
   if (SOAP_MAXALLOCSIZE > 0 && n > SOAP_MAXALLOCSIZE)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   if (!soap)
     return SOAP_MALLOC(soap, n);
   n += sizeof(short);
   n += (~n+1) & (sizeof(void*)-1); /* align at 4-, 8- or 16-byte boundary by rounding up */
   if (n + sizeof(void*) + sizeof(size_t) < k)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   p = (char*)SOAP_MALLOC(soap, n + sizeof(void*) + sizeof(size_t));
   if (!p)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   /* set a canary word to detect memory overruns and data corruption */
   *(unsigned short*)(p + n - sizeof(unsigned short)) = (unsigned short)SOAP_CANARY;
   /* keep chain of alloced cells for destruction */
   *(void**)(p + n) = soap->alist;
   *(size_t*)(p + n + sizeof(void*)) = n;
   soap->alist = p + n;
   return p;
 }

References soap::alist, soap::error, NULL, SOAP_CANARY, SOAP_EOM, SOAP_MALLOC, and SOAP_MAXALLOCSIZE.

Referenced by soap_alloc_multipart(), soap_attachment(), soap_attribute(), soap_base642s(), soap_dime_option(), soap_element(), soap_element_start_end_out(), soap_encode_url_string(), soap_getbase64(), soap_getdimefield(), soap_gethex(), soap_hex2s(), soap_http_get_body_prefix(), soap_id_enter(), soap_id_lookup(), soap_in_PointerToSOAP_ENV__Code(), soap_in_PointerToSOAP_ENV__Detail(), soap_in_PointerToSOAP_ENV__Reason(), soap_in_PointerTostring(), soap_inliteral(), soap_instring(), soap_inwliteral(), soap_inwstring(), soap_memdup(), soap_new_byte(), soap_new_int(), soap_new_string(), soap_peek_element(), soap_resolve(), soap_s2base64(), soap_s2hex(), soap_save_block(), soap_select_mime_boundary(), soap_set_endpoint(), soap_strdup(), soap_wchar2s(), and soap_wstrdup().

◆ soap_mark_cycle()

SOAP_FMAC1 int SOAP_FMAC2 soap_mark_cycle	(	struct soap *	soap,
		struct soap_plist *	pp
	)

Definition at line 13760 of file stdsoap2.cpp.

 {
   (void)soap;
   return pp && pp->mark1 == 2 && (soap->mode & SOAP_XML_TREE);
 }

References soap_plist::mark1, soap::mode, and SOAP_XML_TREE.

◆ soap_mark_dup()

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_dup	(	struct soap *	soap,
		void *	a,
		struct soap_plist *	pp
	)

Definition at line 13771 of file stdsoap2.cpp.

 {
   (void)soap;
   if (pp)
     pp->dup = a;
 }

References mpq::a, and soap_plist::dup.

◆ soap_mark_lookup()

SOAP_FMAC1 void* SOAP_FMAC2 soap_mark_lookup	(	struct soap *	soap,
		const void *	p,
		int	t,
		struct soap_plist **	pp,
		char **	mark
	)

Definition at line 13725 of file stdsoap2.cpp.

 {
   if (!soap)
     return NULL;
   if (mark || !(soap->mode & SOAP_XML_TREE))
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Mark lookup %p type=%d\n", p, t));
     if (!soap_pointer_lookup(soap, p, t, ppp))
     {
       if (!soap_pointer_enter(soap, p, NULL, 0, t, ppp))
         return NULL;
     }
     else if (!(soap->mode & SOAP_XML_TREE))
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Mark found %p\n", (*ppp)->dup));
       return (*ppp)->dup;
     }
     if (mark)
     {
       if ((*ppp)->mark1 > 0)
         (*ppp)->mark1 = 2; /* cycle */
       else
         (*ppp)->mark1 = 1; /* cycle detection */
       *mark = &(*ppp)->mark1;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Mark cycle %d\n", (*ppp)->mark1));
     }
   }
   return NULL;
 }

References DBGLOG, soap::mode, NULL, soap_pointer_enter(), soap_pointer_lookup(), SOAP_XML_TREE, and TEST().

◆ soap_match_array()

SOAP_FMAC1 int SOAP_FMAC2 soap_match_array	(	struct soap *	soap,
		const char *	type
	)

Definition at line 3894 of file stdsoap2.cpp.

 {
   if (type && *soap->arrayType)
   {
     if (soap->version == 1 || !strchr(type, '['))
     {
       if (soap_match_tag(soap, soap->arrayType, type)
         && soap_match_tag(soap, soap->arrayType, "xsd:anyType")
         && soap_match_tag(soap, soap->arrayType, "xsd:ur-type"))
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SOAP array type mismatch: '%s' '%s'\n", soap->arrayType, type));
         return SOAP_TAG_MISMATCH;
       }
     }
   }
   return SOAP_OK;
 }

References soap::arrayType, DBGLOG, soap_match_tag(), SOAP_OK, SOAP_TAG_MISMATCH, TEST(), and soap::version.

◆ soap_match_att()

SOAP_FMAC1 int SOAP_FMAC2 soap_match_att	(	struct soap *	soap,
		const char *	tag1,
		const char *	tag2
	)

Definition at line 3847 of file stdsoap2.cpp.

 {
   const char *s, *t;
   int err;
   if (!tag1 || !tag2 || !*tag2)
     return SOAP_OK;
   s = strchr(tag1, ':');
   t = strchr(tag2, ':');
   if (t)
   {
     if (s)
     {
       if (t[1] && SOAP_STRCMP(s + 1, t + 1))
         return SOAP_TAG_MISMATCH;
       if (t != tag2 && !(soap->mode & SOAP_XML_IGNORENS))
       {
         err = soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2);
         if (err)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Atts '%s' and '%s' match but namespaces differ\n", tag1, tag2));
           if (err == SOAP_NAMESPACE)
             return SOAP_TAG_MISMATCH;
           return err;
         }
       }
     }
     else if (!t[1] || t != tag2 || SOAP_STRCMP(tag1, t + 1))
       return SOAP_TAG_MISMATCH;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Atts and (default) namespaces match: '%s' '%s'\n", tag1, tag2));
     return SOAP_OK;
   }
   if (s)
   {
     if (!(soap->mode & SOAP_XML_IGNORENS) || SOAP_STRCMP(s + 1, tag2)) /* always fails (except when ignoring ns) */
       return SOAP_TAG_MISMATCH;
   }
   else if (SOAP_STRCMP(tag1, tag2))
     return SOAP_TAG_MISMATCH;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Atts match: '%s' '%s'\n", tag1, tag2));
   return SOAP_OK;
 }

References DBGLOG, soap::mode, soap_match_namespace(), SOAP_NAMESPACE, SOAP_OK, SOAP_STRCMP, SOAP_TAG_MISMATCH, SOAP_XML_IGNORENS, and TEST().

Referenced by soap_attr_value().

◆ soap_match_cid()

SOAP_FMAC1 int SOAP_FMAC2 soap_match_cid	(	struct soap *	soap,
		const char *	s,
		const char *	t
	)

Definition at line 19867 of file stdsoap2.cpp.

 {
   size_t n;
   if (!s)
     return 1;
   if (!strcmp(s, t))
     return 0;
   if (!strncmp(s, "cid:", 4))
     s += 4;
   n = strlen(t);
   if (*t == '<')
   {
     t++;
     n -= 2;
   }
   if (!strncmp(s, t, n) && !s[n])
     return 0;
   (void)soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS);
   if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n])
     return 0;
   return 1;
 }

References soap_decode(), SOAP_STR_EOS, and soap::tmpbuf.

Referenced by soap_begin_recv(), and soap_resolve_attachment().

◆ soap_match_namespace()

SOAP_FMAC1 int SOAP_FMAC2 soap_match_namespace	(	struct soap *	soap,
		const char *	id1,
		const char *	id2,
		size_t	n1,
		size_t	n2
	)

Definition at line 3621 of file stdsoap2.cpp.

 {
   struct soap_nlist *np = soap->nlist;
   const char *s;
   while (np && (strncmp(np->id, id1, n1) || np->id[n1]))
     np = np->next;
   if (np)
   {
     if (!(soap->mode & SOAP_XML_IGNORENS) && (n2 > 0 || !np->ns || *np->ns))
     {
       if (np->index < 0
        || ((s = soap->local_namespaces[np->index].id) && (strncmp(s, id2, n2) || (s[n2] && s[n2] != '_'))))
         return SOAP_NAMESPACE;
     }
     return SOAP_OK;
   }
   if (n1 == 0)
     return n2 == 0 || (soap->mode & SOAP_XML_IGNORENS) ? SOAP_OK : SOAP_NAMESPACE;
   if ((n1 == 3 && n1 == n2 && !strncmp(id1, "xml", 3) && !strncmp(id1, id2, 3))
    || (soap->mode & SOAP_XML_IGNORENS))
     return SOAP_OK;
   return soap->error = SOAP_SYNTAX_ERROR;
 }

References soap::error, Namespace::id, soap_nlist::id, soap_nlist::index, soap::local_namespaces, soap::mode, soap_nlist::next, soap::nlist, soap_nlist::ns, SOAP_NAMESPACE, SOAP_OK, SOAP_SYNTAX_ERROR, and SOAP_XML_IGNORENS.

Referenced by soap_match_att(), and soap_match_tag().

◆ soap_match_tag()

SOAP_FMAC1 int SOAP_FMAC2 soap_match_tag	(	struct soap *	soap,
		const char *	tag1,
		const char *	tag2
	)

Definition at line 3776 of file stdsoap2.cpp.

 {
   const char *s, *t;
   int err;
   if (!tag1 || !tag2 || !*tag2)
     return SOAP_OK;
   s = strchr(tag1, ':');
   t = strchr(tag2, ':');
   if (t)
   {
     if (s)
     {
       if (t[1] && SOAP_STRCMP(s + 1, t + 1))
         return SOAP_TAG_MISMATCH;
       if (t != tag2 && !(soap->mode & SOAP_XML_IGNORENS))
       {
         err = soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2);
         if (err)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
           if (err == SOAP_NAMESPACE)
             return SOAP_TAG_MISMATCH;
           return err;
         }
       }
     }
     else if (!t[1])
     {
       if ((soap->mode & SOAP_XML_IGNORENS) || soap_match_namespace(soap, tag1, tag2, 0, t - tag2))
         return SOAP_TAG_MISMATCH;
     }
     else if (SOAP_STRCMP(tag1, t + 1))
     {
       return SOAP_TAG_MISMATCH;
     }
     else if (t != tag2)
     {
       err = soap_match_namespace(soap, tag1, tag2, 0, t - tag2);
       if (err)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
         if (err == SOAP_NAMESPACE)
           return SOAP_TAG_MISMATCH;
         return err;
       }
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags and (default) namespaces match: '%s' '%s'\n", tag1, tag2));
     return SOAP_OK;
   }
   if (s)
   {
     if (!(soap->mode & SOAP_XML_IGNORENS) || SOAP_STRCMP(s + 1, tag2)) /* always fails (except when ignoring ns) */
       return SOAP_TAG_MISMATCH;
   }
   else if (SOAP_STRCMP(tag1, tag2)
 #ifndef WITH_NOEMPTYNAMESPACES
         || ((soap->mode & SOAP_XML_STRICT) && !(soap->mode & SOAP_XML_IGNORENS) && soap_match_namespace(soap, tag1, tag2, 0, 0)) /* strict checking: default namespace must be null namespace */
 #endif
       )
   {
     return SOAP_TAG_MISMATCH;
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags match: '%s' '%s'\n", tag1, tag2));
   return SOAP_OK;
 }

References DBGLOG, endif(), soap::mode, soap_match_namespace(), SOAP_NAMESPACE, SOAP_OK, SOAP_STRCMP, SOAP_TAG_MISMATCH, SOAP_XML_IGNORENS, SOAP_XML_STRICT, and TEST().

Referenced by soap_element_begin_in(), soap_element_end_in(), soap_ignore_element(), soap_inbyte(), soap_indateTime(), soap_inint(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_instantiate_SOAP_ENV__Fault(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), soap_inunsignedShort(), soap_isnumeric(), soap_match_array(), soap_peek_element(), soap_recv_fault(), and soap_serve_request().

◆ soap_memdup()

SOAP_FMAC1 void* SOAP_FMAC2 soap_memdup	(	struct soap *	soap,
		const void *	s,
		size_t	n
	)

Definition at line 2772 of file stdsoap2.cpp.

 {
   void *t = NULL;
   if (s)
   {
     t = soap_malloc(soap, n);
     if (t)
       (void)soap_memcpy(t, n, s, n);
   }
   return t;
 }

References NULL, soap_malloc(), and soap_memcpy.

◆ soap_move()

SOAP_FMAC1 int SOAP_FMAC2 soap_move	(	struct soap *	soap,
		ULONG64	n
	)

Definition at line 2130 of file stdsoap2.cpp.

 {
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving " SOAP_ULONG_FORMAT " bytes forward\n", n));
   for (; n; n--)
     if ((int)soap_getchar(soap) == EOF)
       return SOAP_EOF;
   return SOAP_OK;
 }

References DBGLOG, SOAP_EOF, soap_getchar(), SOAP_OK, SOAP_ULONG_FORMAT, and TEST().

Referenced by soap_getdime(), and soap_getdimefield().

◆ soap_new()

SOAP_FMAC1 struct soap* SOAP_FMAC2 soap_versioning() soap_new	(	soap_mode	imode,
		soap_mode	omode
	)

Definition at line 9564 of file stdsoap2.cpp.

 {
   struct soap *soap;
 #ifdef __cplusplus
   soap = SOAP_NEW_UNMANAGED(struct soap);
 #else
   soap = (struct soap*)SOAP_MALLOC_UNMANAGED(sizeof(struct soap));
 #endif
   if (soap)
     soap_versioning(soap_init)(soap, imode, omode);
   return soap;
 }

References soap::imode, soap::omode, soap, soap_init(), SOAP_MALLOC_UNMANAGED, SOAP_NEW_UNMANAGED, and soap_versioning.

Referenced by soap_copy().

◆ soap_next_block()

SOAP_FMAC1 char* SOAP_FMAC2 soap_next_block	(	struct soap *	soap,
		struct soap_blist *	b
	)

Definition at line 3261 of file stdsoap2.cpp.

 {
   struct soap_bhead *p;
   if (!b)
     b = soap->blist;
   p = b->head;
   if (p)
   {
     b->head = p->next;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Next block %p, deleting current block\n", (void*)(b->head ? b->head + 1 : NULL)));
     SOAP_FREE(soap, p);
     if (b->head)
       return (char*)(b->head + 1);
   }
   return NULL;
 }

References b, soap::blist, DBGLOG, soap_bhead::next, NULL, SOAP_FREE, and TEST().

Referenced by soap_end_send_flush(), and soap_save_block().

◆ soap_next_multipart()

SOAP_FMAC1 struct soap_multipart* SOAP_FMAC2 soap_next_multipart ( struct soap_multipart * content )

Definition at line 20284 of file stdsoap2.cpp.

 {
   if (content)
     return content->next;
   return NULL;
 }

References soap_multipart::next, and NULL.

◆ soap_nth()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_nth	(	struct soap_dom_element *	elt,
		size_t	n
	)

◆ soap_nth_elt()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_nth_elt	(	struct soap_dom_element *	elt,
		const char *	ns,
		const char *	tag,
		size_t	n
	)

◆ soap_nth_elt_w()

SOAP_FMAC1 struct soap_dom_element* SOAP_FMAC2 soap_nth_elt_w	(	struct soap_dom_element *	elt,
		const char *	ns,
		const wchar_t *	tag,
		size_t	n
	)

◆ soap_open_logfile()

SOAP_FMAC1 void SOAP_FMAC2 soap_open_logfile	(	struct soap *	,
		int
	)

◆ soap_outbyte()

SOAP_FMAC1 int SOAP_FMAC2 soap_outbyte	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const char *	p,
		const char *	type,
		int	n
	)

Definition at line 16399 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_long2s(), and soap_string_out().

Referenced by soap_out_byte().

◆ soap_outdateTime()

SOAP_FMAC1 int SOAP_FMAC2 soap_outdateTime	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const time_t *	p,
		const char *	type,
		int	n
	)

Definition at line 18671 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_dateTime2s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_dateTime2s(), soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), and soap_string_out().

◆ soap_outdouble()

SOAP_FMAC1 int SOAP_FMAC2 soap_outdouble	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const double *	p,
		const char *	type,
		int	n
	)

Definition at line 16804 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_double2s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_double2s(), soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), and soap_string_out().

◆ soap_outfloat()

SOAP_FMAC1 int SOAP_FMAC2 soap_outfloat	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const float *	p,
		const char *	type,
		int	n
	)

Definition at line 16593 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_float2s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_float2s(), and soap_string_out().

◆ soap_outint()

SOAP_FMAC1 int SOAP_FMAC2 soap_outint	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const int *	p,
		const char *	type,
		int	n
	)

Definition at line 16104 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_long2s(), and soap_string_out().

Referenced by soap_out_int().

◆ soap_outliteral()

SOAP_FMAC1 int SOAP_FMAC2 soap_outliteral	(	struct soap *	soap,
		const char *	tag,
		char const	p,
		const char *	type
	)

Definition at line 18858 of file stdsoap2.cpp.

 {
   if (tag && *tag != '-')
     if (soap_element_begin_out(soap, tag, 0, type))
       return soap->error;
   if (p && *p)
     if (soap_send(soap, *p)) /* send as-is */
       return soap->error;
   if (tag && *tag != '-')
     return soap_element_end_out(soap, tag);
   return SOAP_OK;
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), SOAP_OK, and soap_send().

Referenced by soap_out_SOAP_ENV__Detail(), and soap_send_fault().

◆ soap_outlong()

SOAP_FMAC1 int SOAP_FMAC2 soap_outlong	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const long *	p,
		const char *	type,
		int	n
	)

Definition at line 16204 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_long2s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_long2s(), and soap_string_out().

◆ soap_outLONG64()

SOAP_FMAC1 int SOAP_FMAC2 soap_outLONG64	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const LONG64 *	p,
		const char *	type,
		int	n
	)

Definition at line 16299 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_LONG642s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_LONG642s(), and soap_string_out().

◆ soap_outshort()

SOAP_FMAC1 int SOAP_FMAC2 soap_outshort	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const short *	p,
		const char *	type,
		int	n
	)

Definition at line 16482 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_long2s(), and soap_string_out().

◆ soap_outstring()

SOAP_FMAC1 int SOAP_FMAC2 soap_outstring	(	struct soap *	soap,
		const char *	tag,
		int	id,
		char const	p,
		const char *	type,
		int	n
	)

Definition at line 18281 of file stdsoap2.cpp.

 {
   id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n, NULL);
   if (id < 0)
     return soap->error;
   if (!**p && (soap->mode & SOAP_C_NILSTRING))
     return soap_element_null(soap, tag, id, type);
   if (soap_element_begin_out(soap, tag, id, type)
    || soap_string_out(soap, *p, 0)
    || soap_element_end_out(soap, tag))
     return soap->error;
   return SOAP_OK;
 }

References soap::error, soap::mode, NULL, SOAP_C_NILSTRING, soap_element_begin_out(), soap_element_end_out(), soap_element_id(), soap_element_null(), SOAP_OK, and soap_string_out().

Referenced by soap_out__QName(), soap_out_string(), and soap_send_fault().

◆ soap_outULONG64()

SOAP_FMAC1 int SOAP_FMAC2 soap_outULONG64	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const ULONG64 *	p,
		const char *	type,
		int	n
	)

Definition at line 17295 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_ULONG642s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_string_out(), and soap_ULONG642s().

◆ soap_outunsignedByte()

SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedByte	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const unsigned char *	p,
		const char *	type,
		int	n
	)

Definition at line 16930 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_string_out(), and soap_unsignedLong2s().

◆ soap_outunsignedInt()

SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedInt	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const unsigned int *	p,
		const char *	type,
		int	n
	)

Definition at line 17097 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_string_out(), and soap_unsignedLong2s().

◆ soap_outunsignedLong()

SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedLong	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const unsigned long *	p,
		const char *	type,
		int	n
	)

Definition at line 17196 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_unsignedLong2s(soap, *p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_string_out(), and soap_unsignedLong2s().

◆ soap_outunsignedShort()

SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedShort	(	struct soap *	soap,
		const char *	tag,
		int	id,
		const unsigned short *	p,
		const char *	type,
		int	n
	)

Definition at line 17013 of file stdsoap2.cpp.

 {
   if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
     return soap->error;
   return soap_element_end_out(soap, tag);
 }

References soap::error, soap_element_begin_out(), soap_element_end_out(), soap_embedded_id(), soap_string_out(), and soap_unsignedLong2s().

◆ soap_outwliteral()

SOAP_FMAC1 int SOAP_FMAC2 soap_outwliteral	(	struct soap *	soap,
		const char *	tag,
		wchar_t const	p,
		const char *	type
	)

Definition at line 18923 of file stdsoap2.cpp.

 {
   if (tag && *tag != '-')
     if (soap_element_begin_out(soap, tag, 0, type))
       return soap->error;
   if (p)
   {
     wchar_t c;
     const wchar_t *s = *p;
     while ((c = *s++))
     {
       if (soap_pututf8(soap, (unsigned long)c)) /* send as-is in UTF8 */
         return soap->error;
     }
   }
   if (tag && *tag != '-')
     return soap_element_end_out(soap, tag);
   return SOAP_OK;
 }

References mpq::c, soap::error, soap_element_begin_out(), soap_element_end_out(), SOAP_OK, and soap_pututf8().

◆ soap_outwstring()

SOAP_FMAC1 int SOAP_FMAC2 soap_outwstring	(	struct soap *	soap,
		const char *	tag,
		int	id,
		wchar_t const	p,
		const char *	type,
		int	n
	)

Definition at line 18359 of file stdsoap2.cpp.

 {
   id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n, NULL);
   if (id < 0)
     return soap->error;
   if (!**p && (soap->mode & SOAP_C_NILSTRING))
     return soap_element_null(soap, tag, id, type);
   if (soap_element_begin_out(soap, tag, id, type)
    || soap_wstring_out(soap, *p, 0)
    || soap_element_end_out(soap, tag))
     return soap->error;
   return SOAP_OK;
 }

References soap::error, soap::mode, NULL, SOAP_C_NILSTRING, soap_element_begin_out(), soap_element_end_out(), soap_element_id(), soap_element_null(), SOAP_OK, and soap_wstring_out().

◆ soap_PATCH()

SOAP_FMAC1 int SOAP_FMAC2 soap_PATCH	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action,
		const char *	type
	)

Definition at line 21297 of file stdsoap2.cpp.

 {
   soap->http_content = type;
   if ((soap->omode & SOAP_IO) != SOAP_IO_CHUNK)
   {
     soap->omode &= ~SOAP_IO;
     soap->omode |= SOAP_IO_STORE;
   }
   return soap_connect_command(soap, SOAP_PATCH, endpoint, action);
 }

References soap::http_content, soap::omode, soap_connect_command(), SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, and SOAP_PATCH.

Referenced by soap_PATCH__QName(), soap_PATCH_byte(), soap_PATCH_int(), soap_PATCH_ns1__executeCommand(), soap_PATCH_ns1__executeCommandResponse(), soap_PATCH_SOAP_ENV__Code(), soap_PATCH_SOAP_ENV__Detail(), soap_PATCH_SOAP_ENV__Fault(), soap_PATCH_SOAP_ENV__Header(), soap_PATCH_SOAP_ENV__Reason(), and soap_PATCH_string().

◆ soap_peek_element()

SOAP_FMAC1 int SOAP_FMAC2 soap_peek_element ( struct soap * soap )

Definition at line 14442 of file stdsoap2.cpp.

 {
 #ifdef WITH_DOM
   struct soap_dom_attribute **att = NULL;
   char *lead = NULL;
 #endif
   struct soap_attribute *tp, *tq = NULL;
   const char *t;
   char *s;
   soap_wchar c;
   int i;
   if (soap->peeked)
   {
     if (!*soap->tag)
       return soap->error = SOAP_NO_TAG;
     return SOAP_OK;
   }
   soap->peeked = 1;
   soap->id[0] = '\0';
   soap->href[0] = '\0';
   soap->type[0] = '\0';
   soap->arrayType[0] = '\0';
   soap->arraySize[0] = '\0';
   soap->arrayOffset[0] = '\0';
   soap->other = 0;
   soap->root = -1;
   soap->position = 0;
   soap->null = 0;
   soap->mustUnderstand = 0;
   /* UTF-8 BOM? */
   c = soap_getchar(soap);
   if (c == 0xEF && soap_get0(soap) == 0xBB)
   {
     soap_get1(soap);
     c = soap_get1(soap);
     if (c == 0xBF)
       soap->mode &= ~SOAP_ENC_LATIN;
     else
       soap_unget(soap, (0x0F << 12) | (0xBB << 6) | (c & 0x3F)); /* UTF-8 */
   }
   else if ((c == 0xFE && soap_get0(soap) == 0xFF)  /* UTF-16 BE */
         || (c == 0xFF && soap_get0(soap) == 0xFE)) /* UTF-16 LE */
   {
     return soap->error = SOAP_UTF_ERROR;
   }
   else
   {
     soap_unget(soap, c);
   }
   c = soap_get(soap);
 #ifdef WITH_DOM
   /* whitespace leading up to the start tag is significant for DOM as-is (but comments and PIs are removed from this lead) */
   if (soap_coblank(c))
   {
     soap->labidx = 0;
     do
     {
       if (soap_append_lab(soap, NULL, 0))
         return soap->error;
       s = soap->labbuf + soap->labidx;
       i = soap->lablen - soap->labidx;
       soap->labidx = soap->lablen;
       while (soap_coblank(c) && i-- > 0)
       {
         *s++ = c;
         c = soap_get(soap);
       }
     } while (soap_coblank(c) || i == 0);
     *s = '\0';
     lead = soap->labbuf;
   }
 #else
   /* skip space */
   while (soap_coblank(c))
     c = soap_get(soap);
 #endif
   if (c != SOAP_LT)
   {
     *soap->tag = '\0';
     if ((int)c == EOF)
       return soap->error = SOAP_CHK_EOF;
     soap_unget(soap, c);
 #ifdef WITH_DOM
     /* whitespace leading up to the end tag is significant for DOM as-is */
     if ((soap->mode & SOAP_XML_DOM) && soap->dom)
     {
       if (lead && *lead)
         soap->dom->tail = soap_strdup(soap, lead);
       else
         soap->dom->tail = SOAP_STR_EOS; /* body with closing tag instead of <tag/> */
     }
 #endif
     return soap->error = SOAP_NO_TAG;
   }
   do
   {
     c = soap_get1(soap);
   } while (soap_coblank(c));
   s = soap->tag;
   i = sizeof(soap->tag);
   while (c != '>' && c != '/' && c > 32 && (int)c != EOF)
   {
     if (i > 1)
     {
       *s++ = (char)c;
       i--;
     }
     c = soap_get1(soap);
   }
   *s = '\0';
   while (soap_coblank(c))
     c = soap_get1(soap);
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM))
   {
     struct soap_dom_element *elt;
     elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
     if (!elt)
       return soap->error;
     elt->next = NULL;
     elt->prnt = soap->dom;
     elt->elts = NULL;
     elt->atts = NULL;
     elt->nstr = NULL;
     elt->name = soap_strdup(soap, soap->tag);
     elt->text = NULL;
     elt->code = NULL;
     elt->tail = NULL;
     elt->node = NULL;
     elt->type = 0;
     if (lead && *lead)
       elt->lead = soap_strdup(soap, lead);
     else
       elt->lead = NULL;
     elt->soap = soap;
     if (soap->dom)
     {
       struct soap_dom_element *p = soap->dom->elts;
       if (p)
       {
         while (p->next)
           p = p->next;
         p->next = elt;
       }
       else
       {
         soap->dom->elts = elt;
       }
     }
     soap->dom = elt;
     att = &elt->atts;
     if (!elt->name)
       return soap->error = SOAP_EOM;
   }
 #endif
   soap_pop_namespace(soap);
   for (tp = soap->attributes; tp; tp = tp->next)
     tp->visible = 0;
   while ((int)c != EOF && c != '>' && c != '/')
   {
     s = soap->tmpbuf;
     i = sizeof(soap->tmpbuf);
     while (c != '=' && c != '>' && c != '/' && c > 32 && (int)c != EOF)
     {
       if (i > 1)
       {
         *s++ = (char)c;
         i--;
       }
       c = soap_get1(soap);
     }
     *s = '\0';
     if (i == sizeof(soap->tmpbuf))
       return soap->error = SOAP_SYNTAX_ERROR;
 #ifdef WITH_DOM
     /* add attribute name to dom */
     if (att)
     {
       *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
        if (!*att)
          return soap->error;
        (*att)->next = NULL;
        (*att)->nstr = NULL;
        (*att)->name = soap_strdup(soap, soap->tmpbuf);
        (*att)->text = NULL;
        (*att)->soap = soap;
        if (!(*att)->name)
          return soap->error = SOAP_EOM;
     }
 #endif
     if (!strncmp(soap->tmpbuf, "xmlns", 5))
     {
       if (soap->tmpbuf[5] == ':')
         t = soap->tmpbuf + 6;
       else if (soap->tmpbuf[5])
         t = NULL;
       else
         t = SOAP_STR_EOS;
     }
     else
     {
       t = NULL;
     }
     tq = NULL;
     for (tp = soap->attributes; tp; tq = tp, tp = tp->next)
     {
       if (!SOAP_STRCMP(tp->name, soap->tmpbuf))
         break;
     }
     if (!tp)
     {
       size_t l = strlen(soap->tmpbuf);
       tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + l);
       if (!tp)
         return soap->error = SOAP_EOM;
       (void)soap_memcpy((char*)tp->name, l + 1, soap->tmpbuf, l + 1);
       tp->value = NULL;
       tp->size = 0;
       tp->ns = NULL;
       tp->visible = 0;
       /* append attribute to the end of the list */
       if (tq)
       {
         tq->next = tp;
         tp->next = NULL;
       }
       else
       {
         tp->next = soap->attributes;
         soap->attributes = tp;
       }
     }
     while (soap_coblank(c))
       c = soap_get1(soap);
     if (c == '=')
     {
       size_t k;
       do
       {
         c = soap_getutf8(soap);
       } while (soap_coblank(c));
       if (c != SOAP_QT && c != SOAP_AP)
       {
         soap_unget(soap, c);
         c = ' '; /* blank delimiter */
       }
       k = tp->size;
       if (soap_getattrval(soap, tp->value, &k, c))
       {
 #ifdef WITH_FAST
         if (soap->error != SOAP_EOM)
           return soap->error;
         soap->error = SOAP_OK;
         if (soap_store_lab(soap, tp->value, k))
           return soap->error;
         if (tp->value)
           SOAP_FREE(soap, tp->value);
         tp->value = NULL;
         for (;;)
         {
           k = soap->lablen - soap->labidx;
           if (soap_getattrval(soap, soap->labbuf + soap->labidx, &k, c))
           {
             if (soap->error != SOAP_EOM)
               return soap->error;
             soap->error = SOAP_OK;
             soap->labidx = soap->lablen;
             if (soap_append_lab(soap, NULL, 0))
               return soap->error;
           }
           else
           {
             break;
           }
         }
         if (soap->labidx)
         {
           tp->size = soap->lablen;
         }
         else
         {
           tp->size = strlen(soap->labbuf) + 1;
           if (tp->size < SOAP_LABLEN)
             tp->size = SOAP_LABLEN;
         }
         tp->value = (char*)SOAP_MALLOC(soap, tp->size);
         if (!tp->value)
           return soap->error = SOAP_EOM;
         soap_strcpy(tp->value, tp->size, soap->labbuf);
 #else
         tp->size = k;
         if (soap->error != SOAP_EOM)
           return soap->error;
         soap->error = SOAP_OK;
         if (soap_alloc_block(soap) == NULL)
           return soap->error;
         for (;;)
         {
           s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN);
           if (!s)
             return soap->error;
           k = SOAP_BLKLEN;
           if (soap_getattrval(soap, s, &k, c))
           {
             if (soap->error != SOAP_EOM)
               return soap->error;
             soap->error = SOAP_OK;
             soap_size_block(soap, NULL, k);
           }
           else
           {
             break;
           }
         }
         k = tp->size + soap->blist->size;
         if (SOAP_MAXALLOCSIZE > 0 && k > SOAP_MAXALLOCSIZE)
           return soap->error = SOAP_EOM;
         s = (char*)SOAP_MALLOC(soap, k);
         if (!s)
           return soap->error = SOAP_EOM;
         if (tp->value)
         {
           (void)soap_memcpy((void*)s, k, (const void*)tp->value, tp->size);
           SOAP_FREE(soap, tp->value);
         }
         soap_save_block(soap, NULL, s + tp->size, 0);
         tp->value = s;
         tp->size = k;
 #endif
       }
       if (tp->visible)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Duplicate attribute in %s\n", soap->tag));
         return soap->error = SOAP_SYNTAX_ERROR; /* redefined (duplicate) attribute */
       }
       tp->visible = 2; /* seen this attribute w/ value */
       do
       {
         c = soap_get1(soap);
       } while (soap_coblank(c));
 #ifdef WITH_DOM
       if (att && tp->value)
       {
         (*att)->text = soap_strdup(soap, tp->value);
         if (!(*att)->text)
           return soap->error = SOAP_EOM;
       }
 #endif
     }
     else
     {
       tp->visible = 1; /* seen this attribute w/o value */
     }
 #ifdef WITH_DOM
     if (att)
       att = &(*att)->next;
 #endif
     if (t && tp->value)
     {
       if (soap_push_namespace(soap, t, tp->value) == NULL)
         return soap->error;
     }
   }
 #ifdef WITH_DOM
   if (att)
   {
     soap->dom->nstr = soap_current_namespace_tag(soap, soap->tag);
     for (att = &soap->dom->atts; *att; att = &(*att)->next)
       (*att)->nstr = soap_current_namespace_att(soap, (*att)->name);
   }
 #endif
   if ((int)c == EOF)
     return soap->error = SOAP_CHK_EOF;
   soap->body = (c != '/');
   if (!soap->body)
   {
     do
     {
       c = soap_get1(soap);
     } while (soap_coblank(c));
   }
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM))
   {
     if (!soap->body && soap->dom->prnt)
       soap->dom = soap->dom->prnt;
   }
 #endif
   for (tp = soap->attributes; tp; tp = tp->next)
   {
     if (tp->visible && tp->value)
     {
 #ifndef WITH_NOIDREF
       if (!strcmp(tp->name, "id"))
       {
         if ((soap->version > 0 && !(soap->imode & SOAP_XML_TREE))
          || (soap->mode & SOAP_XML_GRAPH))
         {
           *soap->id = '#';
           soap_strcpy(soap->id + 1, sizeof(soap->id) - 1, tp->value);
         }
       }
       else if (!strcmp(tp->name, "href"))
       {
         if ((soap->version == 1 && !(soap->imode & SOAP_XML_TREE))
          || (soap->mode & SOAP_XML_GRAPH)
          || ((soap->mode & (SOAP_ENC_MTOM | SOAP_ENC_DIME)) && *tp->value != '#'))
           soap_strcpy(soap->href, sizeof(soap->href), tp->value);
       }
       else if (!strcmp(tp->name, "ref"))
       {
         if ((soap->version == 2 && !(soap->imode & SOAP_XML_TREE))
          || (soap->mode & SOAP_XML_GRAPH))
         {
           *soap->href = '#';
           soap_strcpy(soap->href + (*tp->value != '#'), sizeof(soap->href) - 1, tp->value);
         }
       }
 #else
       if (!strcmp(tp->name, "href"))
       {
         if ((soap->mode & (SOAP_ENC_MTOM | SOAP_ENC_DIME)) && *tp->value != '#')
           soap_strcpy(soap->href, sizeof(soap->href), tp->value);
       }
 #endif
       else if (!soap_match_tag(soap, tp->name, "xsi:type"))
       {
         soap_strcpy(soap->type, sizeof(soap->type), tp->value);
       }
       else if ((!soap_match_tag(soap, tp->name, "xsi:null")
              || !soap_match_tag(soap, tp->name, "xsi:nil"))
             && (!strcmp(tp->value, "1")
              || !strcmp(tp->value, "true")))
       {
         soap->null = 1;
       }
       else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:encodingStyle"))
       {
         if (!soap->encodingStyle)
           soap->encodingStyle = SOAP_STR_EOS;
         soap_version(soap);
       }
       else if (soap->version == 1)
       {
         if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType"))
         {
           s = soap_strrchr(tp->value, '[');
           if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType))
           {
             (void)soap_strncpy(soap->arrayType, sizeof(soap->arrayType), tp->value, s - tp->value);
             soap_strcpy(soap->arraySize, sizeof(soap->arraySize), s);
           }
           else
             soap_strcpy(soap->arrayType, sizeof(soap->arrayType), tp->value);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:offset"))
         {
           soap_strcpy(soap->arrayOffset, sizeof(soap->arrayOffset), tp->value);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:position"))
         {
           soap->position = soap_getposition(tp->value, soap->positions);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:root"))
         {
           soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true")));
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
               && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
         {
           soap->mustUnderstand = 1;
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:actor"))
         {
           if ((!soap->actor || strcmp(soap->actor, tp->value))
            && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next"))
             soap->other = 1;
         }
       }
       else if (soap->version == 2)
       {
 #ifndef WITH_NOIDREF
         if (!soap_match_tag(soap, tp->name, "SOAP-ENC:id"))
         {
           *soap->id = '#';
           soap_strcpy(soap->id + 1, sizeof(soap->id) - 1, tp->value);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:ref"))
         {
           *soap->href = '#';
           soap_strcpy(soap->href + (*tp->value != '#'), sizeof(soap->href) - 1, tp->value);
         }
         else
 #endif
         if (!soap_match_tag(soap, tp->name, "SOAP-ENC:itemType"))
         {
           soap_strcpy(soap->arrayType, sizeof(soap->arrayType), tp->value);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize"))
         {
           soap_strcpy(soap->arraySize, sizeof(soap->arraySize), tp->value);
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
               && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
         {
           soap->mustUnderstand = 1;
         }
         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:role"))
         {
           if ((!soap->actor || strcmp(soap->actor, tp->value))
            && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next"))
             soap->other = 1;
         }
       }
       else
       {
         if (!soap_match_tag(soap, tp->name, "wsdl:required") && !strcmp(tp->value, "true"))
           soap->mustUnderstand = 1;
       }
     }
   }
 #ifdef WITH_DOM
   if (soap->feltbegin)
     return soap->error = soap->feltbegin(soap, soap->tag);
 #endif
   return soap->error = SOAP_OK;
 }

Referenced by soap_element_begin_in(), soap_getelement(), soap_ignore_element(), soap_serve_request(), and soap_xop_forward().

◆ soap_pointer_enter()

SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_enter	(	struct soap *	soap,
		const void *	p,
		const void *	a,
		int	n,
		int	t,
		struct soap_plist **	ppp
	)

Definition at line 9679 of file stdsoap2.cpp.

 {
   size_t h;
   struct soap_plist *pp;
   (void)n;
   if (!soap->pblk || soap->pidx >= SOAP_PTRBLK)
   {
     struct soap_pblk *pb = (struct soap_pblk*)SOAP_MALLOC(soap, sizeof(struct soap_pblk));
     if (!pb)
     {
       soap->error = SOAP_EOM;
       return 0;
     }
     pb->next = soap->pblk;
     soap->pblk = pb;
     soap->pidx = 0;
   }
   *ppp = pp = &soap->pblk->plist[soap->pidx++];
   if (a)
     h = soap_hash_ptr(a);
   else
     h = soap_hash_ptr(p);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pointer enter location=%p array=%p size=%lu type=%d id=%d\n", p, a, (unsigned long)n, type, soap->idnum+1));
   pp->next = soap->pht[h];
   pp->type = type;
   pp->mark1 = 0;
   pp->mark2 = 0;
   pp->ptr = p;
   pp->dup = NULL;
   pp->array = a;
   pp->size = n;
   soap->pht[h] = pp;
   pp->id = ++soap->idnum;
   return pp->id;
 }

References mpq::a, soap_plist::array, DBGLOG, soap_plist::dup, soap::error, soap_plist::id, soap::idnum, soap_plist::mark1, soap_plist::mark2, soap_plist::next, soap_pblk::next, NULL, soap::pblk, soap::pht, soap::pidx, soap_pblk::plist, soap_plist::ptr, soap_plist::size, SOAP_EOM, soap_hash_ptr, SOAP_MALLOC, SOAP_PTRBLK, TEST(), and soap_plist::type.

Referenced by soap_array_reference(), soap_attachment(), soap_attachment_reference(), soap_check_and_mark(), soap_mark_lookup(), and soap_reference().

◆ soap_pointer_lookup()

SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_lookup	(	struct soap *	soap,
		const void *	p,
		int	t,
		struct soap_plist **	ppp
	)

Definition at line 9654 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   *ppp = NULL;
   if (p)
   {
     for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next)
     {
       if (pp->ptr == p && pp->type == type)
       {
         *ppp = pp;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d id=%d\n", p, type, pp->id));
         return pp->id;
       }
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d: not found\n", p, type));
   return 0;
 }

References DBGLOG, soap_plist::id, soap_plist::next, NULL, soap::pht, soap_plist::ptr, soap_hash_ptr, TEST(), and soap_plist::type.

Referenced by soap_check_and_mark(), soap_element_id(), soap_embed(), soap_embedded(), soap_embedded_id(), soap_mark_lookup(), and soap_reference().

◆ soap_pointer_lookup_id()

SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_lookup_id	(	struct soap *	,
		void *	p,
		int	t,
		struct soap_plist **
	)

◆ soap_poll()

SOAP_FMAC1 int SOAP_FMAC2 soap_poll ( struct soap * soap )

Definition at line 6907 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEAN
   int r;
   if (soap_valid_socket(soap->socket))
   {
     r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_ALL, 0);
     if (r > 0 && (r & SOAP_TCP_SELECT_ERR))
       r = -1;
   }
   else if (soap_valid_socket(soap->master))
   {
     r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, 0);
   }
   else
   {
     return SOAP_OK; /* OK when no socket! */
   }
   if (r > 0)
   {
     int t;
 #ifdef WITH_OPENSSL
     if ((soap->imode & SOAP_ENC_SSL) && soap->ssl)
     {
       if (soap_valid_socket(soap->socket)
        && (r & SOAP_TCP_SELECT_SND)
        && (!(r & SOAP_TCP_SELECT_RCV)
         || SSL_peek(soap->ssl, (char*)&t, 1) > 0))
         return SOAP_OK;
     }
     else
 #endif
     {
       if (soap_valid_socket(soap->socket)
        && (r & SOAP_TCP_SELECT_SND)
        && (!(r & SOAP_TCP_SELECT_RCV)
         || recv(soap->socket, (char*)&t, 1, MSG_PEEK) > 0))
         return SOAP_OK;
     }
   }
   else if (r < 0)
   {
     if ((soap_valid_socket(soap->master) && soap_socket_errno != SOAP_EINTR)
      || (soap_valid_socket(soap->socket) && soap_socket_errno != SOAP_EINTR))
       return soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR);
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_poll: other end down on socket=%d select=%d\n", (int)soap->socket, r));
   return SOAP_EOF;
 #else
   (void)soap;
   return SOAP_OK;
 #endif
 }

References DBGLOG, soap::imode, soap::master, SOAP_EINTR, SOAP_ENC_SSL, SOAP_EOF, SOAP_OK, soap_set_receiver_error(), soap_socket_errno, SOAP_TCP_ERROR, SOAP_TCP_SELECT_ALL, SOAP_TCP_SELECT_ERR, SOAP_TCP_SELECT_RCV, SOAP_TCP_SELECT_SND, soap_valid_socket, soap::socket, soap::ssl, tcp_error(), tcp_select(), and TEST().

Referenced by soap_done(), and soap_init().

◆ soap_pop_block()

SOAP_FMAC1 void SOAP_FMAC2 soap_pop_block	(	struct soap *	soap,
		struct soap_blist *	b
	)

Definition at line 2958 of file stdsoap2.cpp.

 {
   struct soap_bhead *p;
   if (!b)
     b = soap->blist;
   if (!b || !b->head)
     return;
   p = b->head;
   b->size -= p->size;
   b->head = p->next;
   b->item--;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop block %p (%lu items of %lu bytes total)\n", (void*)p, (unsigned long)b->item, (unsigned long)b->size));
   SOAP_FREE(soap, p);
 }

References b, soap::blist, DBGLOG, soap_bhead::next, soap_bhead::size, SOAP_FREE, and TEST().

◆ soap_pop_namespace()

SOAP_FMAC1 void SOAP_FMAC2 soap_pop_namespace ( struct soap * soap )

Definition at line 3604 of file stdsoap2.cpp.

 {
   struct soap_nlist *np, *nq;
   for (np = soap->nlist; np && np->level >= soap->level; np = nq)
   {
     nq = np->next;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop namespace binding (level=%u) '%s' level=%u\n", soap->level, np->id, np->level));
     SOAP_FREE(soap, np);
   }
   soap->nlist = np;
 }

References DBGLOG, soap_nlist::id, soap_nlist::level, soap::level, soap_nlist::next, soap::nlist, SOAP_FREE, and TEST().

Referenced by soap_element_end(), soap_element_end_in(), soap_element_start_end_out(), and soap_peek_element().

◆ soap_POST()

SOAP_FMAC1 int SOAP_FMAC2 soap_POST	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action,
		const char *	type
	)

Definition at line 21279 of file stdsoap2.cpp.

 {
   soap->http_content = type;
   if ((soap->omode & SOAP_IO) != SOAP_IO_CHUNK)
   {
     soap->omode &= ~SOAP_IO;
     soap->omode |= SOAP_IO_STORE;
   }
   return soap_connect_command(soap, SOAP_POST_FILE, endpoint, action);
 }

References soap::http_content, soap::omode, soap_connect_command(), SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, and SOAP_POST_FILE.

Referenced by soap_POST_send__QName(), soap_POST_send_byte(), soap_POST_send_int(), soap_POST_send_ns1__executeCommand(), soap_POST_send_ns1__executeCommandResponse(), soap_POST_send_SOAP_ENV__Code(), soap_POST_send_SOAP_ENV__Detail(), soap_POST_send_SOAP_ENV__Fault(), soap_POST_send_SOAP_ENV__Header(), soap_POST_send_SOAP_ENV__Reason(), and soap_POST_send_string().

◆ soap_post_check_mime_attachments()

SOAP_FMAC1 void SOAP_FMAC2 soap_post_check_mime_attachments ( struct soap * soap )

Definition at line 19674 of file stdsoap2.cpp.

 {
   soap->imode |= SOAP_MIME_POSTCHECK;
 }

References soap::imode, and SOAP_MIME_POSTCHECK.

◆ soap_print_fault()

SOAP_FMAC1 void SOAP_FMAC2 soap_print_fault	(	struct soap *	soap,
		FILE *	fd
	)

Definition at line 22667 of file stdsoap2.cpp.

 {
   if (soap_check_state(soap))
   {
     fprintf(fd, "Error: soap struct state not initialized\n");
   }
   else if (soap->error)
   {
     const char **c, *v = NULL, *s, *d;
     c = soap_faultcode(soap);
     if (!*c)
     {
       soap_set_fault(soap);
       c = soap_faultcode(soap);
     }
     if (soap->version == 2)
       v = soap_fault_subcode(soap);
     s = soap_fault_string(soap);
     d = soap_fault_detail(soap);
     fprintf(fd, "%s%d fault %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c, v ? v : "no subcode", s ? s : "[no reason]", d ? d : "[no detail]");
   }
 }

References mpq::c, mpq::d, soap::error, fprintf(), NULL, soap_check_state, soap_fault_detail(), soap_fault_string(), soap_fault_subcode(), soap_faultcode(), soap_set_fault(), and soap::version.

◆ soap_print_fault_location()

SOAP_FMAC1 void SOAP_FMAC2 soap_print_fault_location	(	struct soap *	soap,
		FILE *	fd
	)

Definition at line 22784 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEAN
   int i, j, c1, c2;
   if (soap_check_state(soap) == SOAP_OK && soap->error && soap->error != SOAP_STOP && soap->bufidx <= soap->buflen && soap->buflen > 0 && soap->buflen <= sizeof(soap->buf))
   {
     i = (int)soap->bufidx - 1;
     if (i <= 0)
       i = 0;
     c1 = soap->buf[i];
     soap->buf[i] = '\0';
     if ((int)soap->buflen >= i + 1024)
       j = i + 1023;
     else
       j = (int)soap->buflen - 1;
     c2 = soap->buf[j];
     soap->buf[j] = '\0';
     fprintf(fd, "%s%c\n<!-- ** HERE ** -->\n", soap->buf, c1);
     if (soap->bufidx < soap->buflen)
       fprintf(fd, "%s\n", soap->buf + soap->bufidx);
     soap->buf[i] = (char)c1;
     soap->buf[j] = (char)c2;
   }
 #else
   (void)soap;
   (void)fd;
 #endif
 }

References soap::buf, soap::bufidx, soap::buflen, soap::error, fprintf(), if(), soap_check_state, SOAP_OK, and SOAP_STOP.

◆ soap_push_block()

SOAP_FMAC1 void* SOAP_FMAC2 soap_push_block	(	struct soap *	soap,
		struct soap_blist *	b,
		size_t	n
	)

Definition at line 2910 of file stdsoap2.cpp.

 {
   struct soap_bhead *p;
   if (!b)
     b = soap->blist;
   if (!b
    || b->size + n < b->size
    || sizeof(struct soap_bhead) + n < n
    || (SOAP_MAXALLOCSIZE > 0 && sizeof(struct soap_bhead) + n > SOAP_MAXALLOCSIZE))
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   p = (struct soap_bhead*)SOAP_MALLOC(soap, sizeof(struct soap_bhead) + n);
   if (!p)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   p->next = b->head;
   b->head = p;
   p->size = n;
   b->size += n;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block %p of %u bytes on %lu previous blocks (%lu bytes total)\n", (void*)p, (unsigned int)n, (unsigned long)b->item, (unsigned long)b->size));
   b->item++;
   return (void*)(p + 1); /* skip block header and point to n allocated bytes */
 }

References b, soap::blist, DBGLOG, soap::error, soap_bhead::next, NULL, soap_bhead::size, SOAP_EOM, SOAP_MALLOC, SOAP_MAXALLOCSIZE, and TEST().

Referenced by soap_end_send_flush(), soap_flush_raw(), soap_getdime(), soap_gethex(), soap_http_get_body_prefix(), soap_peek_element(), soap_push_block_max(), soap_QName(), soap_QName2s(), soap_recv_mime_attachment(), soap_string_in(), and soap_wstring_in().

◆ soap_push_block_max()

SOAP_FMAC1 void* SOAP_FMAC2 soap_push_block_max	(	struct soap *	soap,
		struct soap_blist *	b,
		size_t	n
	)

Definition at line 2943 of file stdsoap2.cpp.

 {
   if (b && b->item >= soap->maxoccurs) /* restrict block array length */
   {
     soap->error = SOAP_OCCURS;
     return NULL;
   }
   return soap_push_block(soap, b, n);
 }

References b, soap::error, soap::maxoccurs, NULL, SOAP_OCCURS, and soap_push_block().

◆ soap_push_namespace()

SOAP_FMAC1 struct soap_nlist* SOAP_FMAC2 soap_push_namespace	(	struct soap *	soap,
		const char *	id,
		const char *	ns
	)

Definition at line 3535 of file stdsoap2.cpp.

 {
   struct soap_nlist *np = NULL;
   struct Namespace *p;
   short i = -1;
   size_t n, k;
   n = strlen(id);
   k = strlen(ns) + 1;
   p = soap->local_namespaces;
   if (p)
   {
     for (i = 0; p->id; p++, i++)
     {
       if (p->ns && !strcmp(ns, p->ns))
         break;
       if (p->out)
       {
         if (!strcmp(ns, p->out))
           break;
       }
       else if (p->in)
       {
         if (!soap_tag_cmp(ns, p->in))
         {
           if (SOAP_MAXALLOCSIZE <= 0 || k <= SOAP_MAXALLOCSIZE)
             p->out = (char*)SOAP_MALLOC(soap, k);
           if (p->out)
             soap_strcpy(p->out, k, ns);
           break;
         }
       }
     }
     if (!p->id)
       i = -1;
   }
   if (i >= 0)
     k = 0;
   if (sizeof(struct soap_nlist) + n + k > n && (SOAP_MAXALLOCSIZE <= 0 || sizeof(struct soap_nlist) + n + k <= SOAP_MAXALLOCSIZE))
     np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k);
   if (!np)
   {
     soap->error = SOAP_EOM;
     return NULL;
   }
   np->next = soap->nlist;
   soap->nlist = np;
   np->level = soap->level;
   np->index = i;
   soap_strcpy((char*)np->id, n + 1, id);
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u,index=%hd) '%s'='%s'\n", soap->level, i, id, ns));
   if (i < 0)
   {
     np->ns = np->id + n + 1;
     soap_strcpy((char*)np->ns, k, ns);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns));
   }
   else
   {
     np->ns = NULL;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id));
   }
   return np;
 }

References DBGLOG, soap::error, Namespace::id, soap_nlist::id, Namespace::in, soap_nlist::index, soap_nlist::level, soap::level, soap::local_namespaces, soap_nlist::next, soap::nlist, Namespace::ns, soap_nlist::ns, NULL, Namespace::out, SOAP_EOM, SOAP_MALLOC, SOAP_MAXALLOCSIZE, soap_strcpy, soap_tag_cmp(), and TEST().

Referenced by soap_copy_stream(), soap_peek_element(), and soap_set_namespaces().

◆ soap_PUT()

SOAP_FMAC1 int SOAP_FMAC2 soap_PUT	(	struct soap *	soap,
		const char *	endpoint,
		const char *	action,
		const char *	type
	)

Definition at line 21261 of file stdsoap2.cpp.

 {
   soap->http_content = type;
   if ((soap->omode & SOAP_IO) != SOAP_IO_CHUNK)
   {
     soap->omode &= ~SOAP_IO;
     soap->omode |= SOAP_IO_STORE;
   }
   return soap_connect_command(soap, SOAP_PUT, endpoint, action);
 }

References soap::http_content, soap::omode, soap_connect_command(), SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, and SOAP_PUT.

Referenced by soap_PUT__QName(), soap_PUT_byte(), soap_PUT_int(), soap_PUT_ns1__executeCommand(), soap_PUT_ns1__executeCommandResponse(), soap_PUT_SOAP_ENV__Code(), soap_PUT_SOAP_ENV__Detail(), soap_PUT_SOAP_ENV__Fault(), soap_PUT_SOAP_ENV__Header(), soap_PUT_SOAP_ENV__Reason(), and soap_PUT_string().

◆ soap_putbase64()

SOAP_FMAC1 int SOAP_FMAC2 soap_putbase64	(	struct soap *	soap,
		const unsigned char *	s,
		int	n
	)

Definition at line 2469 of file stdsoap2.cpp.

 {
   char d[4 * SOAP_BINARY_BUFLEN], *p = d;
   if (!s)
     return SOAP_OK;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_s2base64(soap, s, NULL, n);
     if (!soap->dom->text)
       return soap->error;
     return SOAP_OK;
   }
 #endif
   for (; n > 2; n -= 3, s += 3)
   {
     p[0] = soap_base64o[(s[0] & 0xFC) >> 2];
     p[1] = soap_base64o[((s[0] & 0x03) << 4) | ((s[1] & 0xF0) >> 4)];
     p[2] = soap_base64o[((s[1] & 0x0F) << 2) | ((s[2] & 0xC0) >> 6)];
     p[3] = soap_base64o[s[2] & 0x3F];
     p += 4;
     if (p - d == sizeof(d))
     {
       if (soap_send_raw(soap, d, sizeof(d)))
         return soap->error;
       p = d;
     }
   }
   if (n == 2)
   {
     p[0] = soap_base64o[(s[0] & 0xFC) >> 2];
     p[1] = soap_base64o[((s[0] & 0x03) << 4) | ((s[1] & 0xF0) >> 4)];
     p[2] = soap_base64o[(s[1] & 0x0F) << 2];
     p[3] = '=';
     p += 4;
   }
   else if (n == 1)
   {
     p[0] = soap_base64o[(s[0] & 0xFC) >> 2];
     p[1] = soap_base64o[(s[0] & 0x03) << 4];
     p[2] = '=';
     p[3] = '=';
     p += 4;
   }
   if (p != d && soap_send_raw(soap, d, p - d))
     return soap->error;
   return SOAP_OK;
 }

References mpq::d, soap::dom, soap::error, soap::mode, NULL, soap_base64o, SOAP_BINARY_BUFLEN, SOAP_OK, soap_s2base64(), soap_send_raw(), SOAP_XML_DOM, and soap_dom_element::text.

◆ soap_putdime()

SOAP_FMAC1 int SOAP_FMAC2 soap_putdime ( struct soap * soap )

Definition at line 19249 of file stdsoap2.cpp.

 {
   struct soap_multipart *content;
   if (!(soap->mode & SOAP_ENC_DIME))
     return SOAP_OK;
   for (content = soap->dime.first; content; content = content->next)
   {
     void *handle;
     soap->dime.size = content->size;
     soap->dime.id = content->id;
     soap->dime.type = content->type;
     soap->dime.options = content->options;
     soap->dime.flags = SOAP_DIME_VERSION | SOAP_DIME_MEDIA;
     if (soap->fdimereadopen && ((handle = soap->fdimereadopen(soap, (void*)content->ptr, content->id, content->type, content->options)) != NULL || soap->error))
     {
       size_t size = content->size;
       if (!handle)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadopen failed\n"));
         return soap->error;
       }
       if (!size && ((soap->mode & SOAP_ENC_PLAIN) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE))
       {
         size_t chunksize = sizeof(soap->tmpbuf);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming DIME\n"));
         do
         {
           size = soap->fdimeread(soap, handle, soap->tmpbuf, chunksize);
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread returned %lu bytes\n", (unsigned long)size));
           if (size < chunksize)
           {
             soap->dime.flags &= ~SOAP_DIME_CF;
             if (!content->next)
               soap->dime.flags |= SOAP_DIME_ME;
           }
           else
           {
             soap->dime.flags |= SOAP_DIME_CF;
           }
           soap->dime.size = size;
           if (soap_putdimehdr(soap)
            || soap_putdimefield(soap, soap->tmpbuf, size))
             break;
           if (soap->dime.id)
           {
             soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA);
             soap->dime.id = NULL;
             soap->dime.type = NULL;
             soap->dime.options = NULL;
           }
         } while (size >= chunksize);
       }
       else
       {
         if (!content->next)
           soap->dime.flags |= SOAP_DIME_ME;
         if (soap_putdimehdr(soap))
           return soap->error;
         do
         {
           size_t bufsize;
           if (size < sizeof(soap->tmpbuf))
             bufsize = size;
           else
             bufsize = sizeof(soap->tmpbuf);
           bufsize = soap->fdimeread(soap, handle, soap->tmpbuf, bufsize);
           if (!bufsize)
           {
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
             soap->error = SOAP_CHK_EOF;
             break;
           }
           if (soap_send_raw(soap, soap->tmpbuf, bufsize))
             break;
           size -= bufsize;
         } while (size);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
         if (soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3))
           return soap->error;
       }
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
       if (soap->fdimereadclose)
         soap->fdimereadclose(soap, handle);
     }
     else
     {
       if (!content->next)
         soap->dime.flags |= SOAP_DIME_ME;
       if (soap_putdimehdr(soap)
        || soap_putdimefield(soap, (char*)content->ptr, content->size))
         return soap->error;
     }
   }
   return SOAP_OK;
 }

References chunksize, DBGLOG, soap::dime, soap::error, soap::fdimeread, soap::fdimereadclose, soap::fdimereadopen, soap_dime::first, soap_dime::flags, soap_dime::id, soap_multipart::id, if(), soap::mode, soap_multipart::next, NULL, soap_dime::options, soap_multipart::options, soap_multipart::ptr, soap_dime::size, soap_multipart::size, SOAP_CHK_EOF, SOAP_DIME_CF, SOAP_DIME_MB, SOAP_DIME_ME, SOAP_DIME_MEDIA, SOAP_DIME_VERSION, SOAP_ENC_DIME, SOAP_ENC_PLAIN, SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, SOAP_OK, soap_putdimefield(), soap_putdimehdr(), soap_send_raw(), SOAP_STR_PADDING, TEST(), soap::tmpbuf, soap_dime::type, and soap_multipart::type.

Referenced by soap_end_send().

◆ soap_putdimehdr()

SOAP_FMAC1 int SOAP_FMAC2 soap_putdimehdr ( struct soap * soap )

Definition at line 19203 of file stdsoap2.cpp.

 {
   unsigned char tmp[12];
   size_t optlen = 0, idlen = 0, typelen = 0;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id ? soap->dime.id : SOAP_STR_EOS));
   if (soap->dime.options)
     optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4;
   if (soap->dime.id)
   {
     idlen = strlen(soap->dime.id);
     if (idlen > 0x0000FFFF)
       idlen = 0x0000FFFF;
   }
   if (soap->dime.type)
   {
     typelen = strlen(soap->dime.type);
     if (typelen > 0x0000FFFF)
       typelen = 0x0000FFFF;
   }
   tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7);
   tmp[1] = soap->dime.flags & 0xF0;
   tmp[2] = (char)(optlen >> 8);
   tmp[3] = (char)(optlen & 0xFF);
   tmp[4] = (char)(idlen >> 8);
   tmp[5] = (char)(idlen & 0xFF);
   tmp[6] = (char)(typelen >> 8);
   tmp[7] = (char)(typelen & 0xFF);
   tmp[8] = (char)(soap->dime.size >> 24);
   tmp[9] = (char)((soap->dime.size >> 16) & 0xFF);
   tmp[10] = (char)((soap->dime.size >> 8) & 0xFF);
   tmp[11] = (char)(soap->dime.size & 0xFF);
   if (soap_send_raw(soap, (char*)tmp, 12)
    || soap_putdimefield(soap, soap->dime.options, optlen)
    || soap_putdimefield(soap, soap->dime.id, idlen)
    || soap_putdimefield(soap, soap->dime.type, typelen))
     return soap->error;
   return SOAP_OK;
 }

References DBGLOG, soap::dime, soap::error, soap_dime::flags, soap_dime::id, soap_dime::options, soap_dime::size, SOAP_DIME_VERSION, SOAP_OK, soap_putdimefield(), soap_send_raw(), SOAP_STR_EOS, TEST(), and soap_dime::type.

Referenced by soap_begin_attachments(), and soap_putdime().

◆ soap_putfault()

SOAP_FMAC3 int SOAP_FMAC4 soap_putfault ( struct soap * soap )

Definition at line 78 of file soapC.cpp.

 {
     if (soap->fault)
         return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", "");
     return SOAP_OK;
 }

References soap::fault, SOAP_OK, and soap_put_SOAP_ENV__Fault().

Referenced by soap_send_fault().

◆ soap_putheader()

SOAP_FMAC3 int SOAP_FMAC4 soap_putheader ( struct soap * soap )

Definition at line 34 of file soapC.cpp.

 {
     if (soap->version && soap->header)
     {   soap->part = SOAP_IN_HEADER;
         if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, ""))
             return soap->error;
         soap->part = SOAP_END_HEADER;
     }
     return SOAP_OK;
 }

References soap::error, soap::header, soap::part, SOAP_END_HEADER, SOAP_IN_HEADER, SOAP_OK, soap_out_SOAP_ENV__Header(), and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_puthex()

SOAP_FMAC1 int SOAP_FMAC2 soap_puthex	(	struct soap *	soap,
		const unsigned char *	s,
		int	n
	)

Definition at line 2303 of file stdsoap2.cpp.

 {
   char d[2 * SOAP_BINARY_BUFLEN], *p = d;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_s2hex(soap, s, NULL, n);
     if (!soap->dom->text)
       return soap->error;
     return SOAP_OK;
   }
 #endif
   for (; n > 0; n--)
   {
     int m = *s++;
     p[0] = (char)((m >> 4) + (m > 159 ? '7' : '0'));
     m &= 0x0F;
     p[1] = (char)(m + (m > 9 ? '7' : '0'));
     p += 2;
     if (p - d == sizeof(d))
     {
       if (soap_send_raw(soap, d, sizeof(d)))
         return soap->error;
       p = d;
     }
   }
   if (p != d && soap_send_raw(soap, d, p - d))
     return soap->error;
   return SOAP_OK;
 }

References mpq::d, soap::dom, soap::error, soap::mode, NULL, SOAP_BINARY_BUFLEN, SOAP_OK, soap_s2hex(), soap_send_raw(), SOAP_XML_DOM, and soap_dom_element::text.

◆ soap_puthttphdr()

SOAP_FMAC1 int SOAP_FMAC2 soap_puthttphdr	(	struct soap *	soap,
		int	status,
		ULONG64	count
	)

Definition at line 21878 of file stdsoap2.cpp.

 {
   int err = SOAP_OK;
   if (soap_http_content_type(soap, status))
   {
     err = soap->fposthdr(soap, "Content-Type", soap->tmpbuf);
     if (err)
       return err;
 #ifdef WITH_ZLIB
     if ((soap->omode & SOAP_ENC_ZLIB))
     {
 #ifdef WITH_GZIP
       err = soap->fposthdr(soap, "Content-Encoding", soap->zlib_out == SOAP_ZLIB_DEFLATE ? "deflate" : "gzip");
 #else
       err = soap->fposthdr(soap, "Content-Encoding", "deflate");
 #endif
       if (err)
         return err;
     }
 #endif
 #ifndef WITH_LEANER
     if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)
     {
       err = soap->fposthdr(soap, "Transfer-Encoding", "chunked");
     }
     else
 #endif
     {
       (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), SOAP_ULONG_FORMAT, count);
       err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf);
     }
     if (err)
       return err;
   }
   if (soap->http_extra_header)
   {
     const char *header = soap->http_extra_header;
     soap->http_extra_header = NULL; /* use http_extra_header once (assign new value before each call) */
     if (*header)
     {
       err = soap_send(soap, header);
       if (err)
         return err;
       err = soap_send_raw(soap, "\r\n", 2);
       if (err)
         return err;
     }
   }
   if (soap->keep_alive)
   {
     if (soap->keep_alive > 0 && soap->recv_timeout)
     {
       int t = soap->recv_timeout;
       if (t < 0)
         t = 1;
       (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), "timeout=%d, max=%d", soap->recv_timeout, soap->keep_alive);
       err = soap->fposthdr(soap, "Keep-Alive", soap->tmpbuf);
       if (err)
         return err;
     }
     return soap->fposthdr(soap, "Connection", "keep-alive");
   }
   return soap->fposthdr(soap, "Connection", "close");
 }

References count(), soap::fposthdr, soap::http_extra_header, soap::keep_alive, NULL, soap::omode, soap::recv_timeout, SOAP_ENC_ZLIB, soap_http_content_type(), SOAP_IO, SOAP_IO_CHUNK, SOAP_OK, soap_send(), soap_send_raw(), SOAP_SNPRINTF, SOAP_ULONG_FORMAT, SOAP_ZLIB_DEFLATE, soap::tmpbuf, and soap::zlib_out.

Referenced by http_post(), and http_response().

◆ soap_putmime()

SOAP_FMAC1 int SOAP_FMAC2 soap_putmime ( struct soap * soap )

Definition at line 20001 of file stdsoap2.cpp.

 {
   struct soap_multipart *content;
   if (!(soap->mode & SOAP_ENC_MIME) || !soap->mime.boundary)
     return SOAP_OK;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending MIME attachments\n"));
   for (content = soap->mime.first; content; content = content->next)
   {
     void *handle;
     if (soap->fmimereadopen && ((handle = soap->fmimereadopen(soap, (void*)content->ptr, content->id, content->type, content->description)) != NULL || soap->error))
     {
       size_t size = content->size;
       if (!handle)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimereadopen failed\n"));
         return soap->error;
       }
       if (soap_putmimehdr(soap, content))
         return soap->error;
       if (!size)
       {
         if ((soap->mode & SOAP_ENC_PLAIN) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming MIME\n"));
           do
           {
             size = soap->fmimeread(soap, handle, soap->tmpbuf, sizeof(soap->tmpbuf));
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread returned %lu bytes\n", (unsigned long)size));
             if (soap_send_raw(soap, soap->tmpbuf, size))
               break;
           } while (size);
         }
         else
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: cannot chunk streaming MIME (no HTTP chunking)\n"));
         }
       }
       else
       {
         do
         {
           size_t bufsize;
           if (size < sizeof(soap->tmpbuf))
             bufsize = size;
           else
             bufsize = sizeof(soap->tmpbuf);
           bufsize = soap->fmimeread(soap, handle, soap->tmpbuf, bufsize);
           if (!bufsize)
           {
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
             soap->error = SOAP_EOF;
             break;
           }
           if (soap_send_raw(soap, soap->tmpbuf, bufsize))
             break;
           size -= bufsize;
         } while (size);
       }
       if (soap->fmimereadclose)
         soap->fmimereadclose(soap, handle);
     }
     else
     {
       if (soap_putmimehdr(soap, content)
        || soap_send_raw(soap, content->ptr, content->size))
         return soap->error;
     }
   }
   return soap_send3(soap, "\r\n--", soap->mime.boundary, "--");
 }

References soap_mime::boundary, DBGLOG, soap_multipart::description, soap::error, soap_mime::first, soap::fmimeread, soap::fmimereadclose, soap::fmimereadopen, soap_multipart::id, soap::mime, soap::mode, soap_multipart::next, NULL, soap_multipart::ptr, soap_multipart::size, SOAP_ENC_MIME, SOAP_ENC_PLAIN, SOAP_EOF, SOAP_IO, SOAP_IO_CHUNK, SOAP_IO_STORE, SOAP_OK, soap_putmimehdr(), soap_send3(), soap_send_raw(), TEST(), soap::tmpbuf, and soap_multipart::type.

Referenced by soap_end_send().

◆ soap_putmimehdr()

SOAP_FMAC1 int SOAP_FMAC2 soap_putmimehdr	(	struct soap *	soap,
		struct soap_multipart *	content
	)

Definition at line 19974 of file stdsoap2.cpp.

 {
   const char *s;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type='%s'\n", content->type ? content->type : SOAP_STR_EOS));
   if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n"))
     return soap->error;
   if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n"))
     return soap->error;
   s = soap_code_str(mime_codes, content->encoding);
   if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n"))
     return soap->error;
   if (content->id && soap_send3(soap, "Content-ID: ", content->id, "\r\n"))
     return soap->error;
   if (content->location && soap_send3(soap, "Content-Location: ", content->location, "\r\n"))
     return soap->error;
   if (content->description && soap_send3(soap, "Content-Description: ", content->description, "\r\n"))
     return soap->error;
   return soap_send_raw(soap, "\r\n", 2);
 }

References soap_mime::boundary, DBGLOG, soap_multipart::description, soap_multipart::encoding, soap::error, soap_multipart::id, soap_multipart::location, soap::mime, mime_codes, soap_code_str(), soap_send3(), soap_send_raw(), SOAP_STR_EOS, TEST(), and soap_multipart::type.

Referenced by soap_putmime().

◆ soap_putoffsets()

SOAP_FMAC1 char* SOAP_FMAC2 soap_putoffsets	(	struct soap *	soap,
		const int *	offset,
		int	dim
	)

Definition at line 3413 of file stdsoap2.cpp.

 {
   int i;
   soap->arrayOffset[0] = '\0';
   if (soap->version == 1)
   {
     (SOAP_SNPRINTF(soap->arrayOffset, sizeof(soap->arrayOffset) - 1, 20), "[%d", offset[0]);
     for (i = 1; i < dim; i++)
     {
       size_t l = strlen(soap->arrayOffset);
       (SOAP_SNPRINTF(soap->arrayOffset + l, sizeof(soap->arrayOffset) - l - 1, 20), ",%d", offset[i]);
     }
     soap_strcat(soap->arrayOffset, sizeof(soap->arrayOffset), "]");
   }
   return soap->arrayOffset;
 }

References soap::arrayOffset, mpq::l, SOAP_SNPRINTF, soap_strcat(), and soap::version.

◆ soap_putsizesoffsets()

SOAP_FMAC1 char* SOAP_FMAC2 soap_putsizesoffsets	(	struct soap *	soap,
		const char *	type,
		const int *	size,
		const int *	offset,
		int	dim
	)

Definition at line 3378 of file stdsoap2.cpp.

 {
   int i;
   const char *t = ",%d";
   if (!type)
     return NULL;
   if (soap->version == 2)
     t = " %d";
   if (soap->version != 2 && offset)
   {
     (SOAP_SNPRINTF(soap->type, sizeof(soap->type) - 1, strlen(type) + 20), "%s[%d", type, size[0] + offset[0]);
     for (i = 1; i < dim; i++)
     {
       size_t l = strlen(soap->type);
       (SOAP_SNPRINTF(soap->type + l, sizeof(soap->type) - l - 1, 20), t, size[i] + offset[i]);
     }
   }
   else
   {
     (SOAP_SNPRINTF(soap->type, sizeof(soap->type) - 1, strlen(type) + 20), "%s[%d", type, size[0]);
     for (i = 1; i < dim; i++)
     {
       size_t l = strlen(soap->type);
       (SOAP_SNPRINTF(soap->type + l, sizeof(soap->type) - l - 1, 20), t, size[i]);
     }
   }
   soap_strcat(soap->type, sizeof(soap->type), "]");
   return soap->type;
 }

References mpq::l, NULL, soap_ilist::size, SOAP_SNPRINTF, soap_strcat(), soap::type, and soap::version.

◆ soap_pututf8()

SOAP_FMAC1 int SOAP_FMAC2 soap_pututf8	(	struct soap *	soap,
		unsigned long	c
	)

Definition at line 2157 of file stdsoap2.cpp.

 {
   char tmp[24];
   if ((c < 0x7F && c > 0x1F))
   {
     *tmp = (char)c;
     return soap_send_raw(soap, tmp, 1);
   }
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
   if (!(c == 0x09 || c == 0x0A || c == 0x0D || (c >= 0x80 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0x10FFFF)))
     c = SOAP_UNKNOWN_UNICODE_CHAR;
 #endif
 #ifndef WITH_LEAN
   if (c > 0x9F)
   {
     char *t = tmp;
     if (c < 0x0800)
     {
       *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
     }
     else
     {
       if (c < 0x010000)
       {
         *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
       }
       else
       {
         if (c < 0x200000)
         {
           *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
         }
         else
         {
           if (c < 0x04000000)
           {
             *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
           }
           else
           {
             *t++ = (char)(0xFC | ((c >> 30) & 0x01));
             *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
           }
           *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
         }
         *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
       }
       *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
     }
     *t++ = (char)(0x80 | (c & 0x3F));
     *t = '\0';
   }
   else
 #endif
     (SOAP_SNPRINTF(tmp, sizeof(tmp), 20), "&#x%lX;", c);
   return soap_send(soap, tmp);
 }

References mpq::c, soap_send(), soap_send_raw(), and SOAP_SNPRINTF.

Referenced by soap_outwliteral(), soap_string_out(), and soap_wstring_out().

◆ soap_QName2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_QName2s	(	struct soap *	soap,
		const char *	s
	)

Definition at line 17752 of file stdsoap2.cpp.

 {
   const char *t = NULL;
   if (s)
   {
 #ifdef WITH_FAST
     soap_store_lab(soap, SOAP_STR_EOS, 1);
     soap->labidx = 0;
 #else
     char *b = NULL;
     if (soap_alloc_block(soap) == NULL)
       return NULL;
 #endif
     for (;;)
     {
       size_t n;
       const char *q = NULL;
       const char *r = NULL;
       size_t m = 0;
 #ifndef WITH_FAST
       size_t k = 0;
 #endif
       /* skip blanks */
       while (*s && soap_coblank((soap_wchar)*s))
         s++;
       if (!*s)
       {
 #ifdef WITH_FAST
         soap->labbuf[soap->labidx > 0 ? soap->labidx - 1 : 0] = '\0';
 #else
         if (!b)
           return soap_strdup(soap, SOAP_STR_EOS);
         --b;
         *b = '\0';
 #endif
         break;
       }
       /* find next QName */
       n = 0;
       while (s[n] && !soap_coblank((soap_wchar)s[n]))
       {
         if (s[n] == ':')
           r = s;
         n++;
       }
       if (*s != '"') /* non-quoted: pass string as is */
       {
 #ifndef WITH_LEAN
         if (r && (soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_XML_CANONICAL_NA))
           soap_utilize_ns(soap, s, 1);
 #endif
         r = s;
         m = n + 1;
       }
       else /* prefix quoted URI-based string */
       {
         q = strchr(s + 1, '"');
         if (q)
         {
           struct Namespace *p = soap->local_namespaces;
           if (p)
           {
             for (; p->id; p++)
             {
               if (p->ns)
                 if (!soap_tag_cmp(s + 1, p->ns))
                   break;
               if (p->in)
                 if (!soap_tag_cmp(s + 1, p->in))
                   break;
             }
           }
           q++;
           /* URL is in the namespace table? */
           if (p && p->id)
           {
             r = p->id;
             m = strlen(r);
           }
           else /* not in namespace table: create xmlns binding */
           {
             char *x = soap_strdup(soap, s + 1);
             if (!x)
               return NULL;
             x[q - s - 2] = '\0';
             (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 27), "xmlns:_%d", soap->idnum++);
             soap_set_attr(soap, soap->tmpbuf, x, 1);
             r = soap->tmpbuf + 6;
             m = strlen(r);
           }
         }
       }
       /* copy normalized QName into buffer, including the ending blank or NUL */
 #ifdef WITH_FAST
       if ((m && soap_append_lab(soap, r, m))
        || (q && soap_append_lab(soap, q, n - (q - s) + 1)))
         return NULL;
 #else
       k = m + (q ? n - (q - s) + 1 : 0);
       b = (char*)soap_push_block(soap, NULL, k);
       if (!b)
       {
         soap->error = SOAP_EOM;
         return NULL;
       }
       if (soap_memcpy((void*)b, k, (const void*)r, m))
       {
         soap->error = SOAP_EOM;
         return NULL;
       }
       b += m;
       if (q)
       {
         if (soap_memcpy((void*)b, k - m, (const void*)q, n - (q - s) + 1))
         {
           soap->error = SOAP_EOM;
           return NULL;
         }
         b += n - (q - s) + 1;
       }
 #endif
       /* advance to next */
       s += n;
     }
 #ifdef WITH_FAST
     t = soap_strdup(soap, soap->labbuf);
     if (!t)
       soap->error = SOAP_EOM;
 #else
     t = (char*)soap_save_block(soap, NULL, NULL, 0);
 #endif
   }
   return t;
 }

References b, soap::error, Namespace::id, soap::idnum, Namespace::in, soap::labbuf, soap::labidx, soap::local_namespaces, soap::mode, Namespace::ns, NULL, soap_alloc_block(), soap_append_lab(), soap_coblank, SOAP_EOM, soap_memcpy, soap_push_block(), soap_save_block(), soap_set_attr(), SOAP_SNPRINTF, soap_store_lab(), SOAP_STR_EOS, soap_strdup(), soap_tag_cmp(), soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_CANONICAL_NA, soap::tmpbuf, and G3D::x.

Referenced by soap_out_SOAP_ENV__Code(), and soap_out_SOAP_ENV__Fault().

◆ soap_query()

SOAP_FMAC1 char* SOAP_FMAC2 soap_query ( struct soap * soap )

Definition at line 1026 of file stdsoap2.cpp.

 {
   return strchr(soap->path, '?');
 }

References soap::path.

◆ soap_query_decode()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_query_decode	(	char *	buf,
		size_t	len,
		const char *	val
	)

Definition at line 1076 of file stdsoap2.cpp.

 {
   const char *s;
   char *t;
   for (s = val; *s; s++)
     if (*s != ' ' && *s != '=')
       break;
   if (*s == '"')
   {
     t = buf;
     s++;
     while (*s && *s != '"' && --len)
       *t++ = *s++;
     *t = '\0';
     do s++;
     while (*s && *s != '&' && *s != '=');
   }
   else
   {
     t = buf;
     while (*s && *s != '&' && *s != '=' && --len)
     {
       switch (*s)
       {
         case '+':
           *t++ = ' ';
           s++;
           break;
         case '\t':
         case '\n':
         case '\r':
         case ' ':
           s++;
           break;
         case '%':
           *t++ = ((s[1] >= 'A' ? (s[1]&0x7) + 9 : s[1] - '0') << 4) + (s[2] >= 'A' ? (s[2]&0x7) + 9 : s[2] - '0');
           s += 3;
           break;
         default:
           *t++ = *s++;
       }
     }
     *t = '\0';
   }
   return s;
 }

Referenced by soap_query_key(), and soap_query_val().

◆ soap_query_key()

SOAP_FMAC1 char* SOAP_FMAC2 soap_query_key	(	struct soap *	soap,
		char **	s
	)

Definition at line 1038 of file stdsoap2.cpp.

 {
   char *t = *s;
   (void)soap;
   if (t && *t)
   {
     *s = (char*)soap_query_decode(t, strlen(t), t + 1);
     return t;
   }
   return *s = NULL;
 }

References NULL, and soap_query_decode().

◆ soap_query_send_key()

SOAP_FMAC1 int SOAP_FMAC2 soap_query_send_key	(	struct soap *	soap,
		const char *	s
	)

Definition at line 991 of file stdsoap2.cpp.

 {
   if (!s)
     return SOAP_OK;
   if (!soap->body && soap_send_raw(soap, "&", 1))
     return soap->error;
   soap->body = 0;
   (void)soap_encode_url(s, soap->msgbuf, (int)sizeof(soap->msgbuf)); /* msgbuf length is max SOAP_TMPLEN or just 1024 bytes */
   return soap_send(soap, soap->msgbuf);
 }

References soap::body, soap::error, soap::msgbuf, soap_encode_url(), SOAP_OK, soap_send(), and soap_send_raw().

◆ soap_query_send_val()

SOAP_FMAC1 int SOAP_FMAC2 soap_query_send_val	(	struct soap *	soap,
		const char *	s
	)

Definition at line 1009 of file stdsoap2.cpp.

 {
   if (!s)
     return SOAP_OK;
   if (soap_send_raw(soap, "=", 1))
     return soap->error;
   (void)soap_encode_url(s, soap->msgbuf, (int)sizeof(soap->msgbuf)); /* msgbuf length is max SOAP_TMPLEN or just 1024 bytes */
   return soap_send(soap, soap->msgbuf);
 }

References soap::error, soap::msgbuf, soap_encode_url(), SOAP_OK, soap_send(), and soap_send_raw().

◆ soap_query_val()

SOAP_FMAC1 char* SOAP_FMAC2 soap_query_val	(	struct soap *	soap,
		char **	s
	)

Definition at line 1057 of file stdsoap2.cpp.

 {
   char *t = *s;
   (void)soap;
   if (t && *t == '=')
   {
     *s = (char*)soap_query_decode(t, strlen(t), t + 1);
     return t;
   }
   return NULL;
 }

References NULL, and soap_query_decode().

◆ soap_rand_uuid()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_rand_uuid	(	struct soap *	soap,
		const char *	prefix
	)

Definition at line 19897 of file stdsoap2.cpp.

 {
   int r1, r2, r3, r4;
 #ifdef WITH_OPENSSL
   r1 = soap_random;
   r2 = soap_random;
 #else
   size_t i;
   static int k = 0xFACEB00C;
   int lo = k % 127773;
   int hi = k / 127773;
 # if defined(HAVE_GETTIMEOFDAY)
   struct timeval tv;
   gettimeofday(&tv, NULL);
   r1 = 10000000 * tv.tv_sec + tv.tv_usec;
 # elif defined(UNDER_CE)
   r1 = (int)Random();
 # elif !defined(WITH_LEAN)
   r1 = (int)time(NULL);
 # else
   r1 = k;
 # endif
   k = 16807 * lo - 2836 * hi;
   if (k <= 0)
     k += 0x7FFFFFFF;
   r2 = k;
   /* k &= 0x8FFFFFFF; */
   for (i = 0; i < (sizeof(soap->buf) < 16UL ? sizeof(soap->buf) : 16UL); i++)
     r2 += soap->buf[i];
 #endif
   r3 = soap_random;
   r4 = soap_random;
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), prefix ? strlen(prefix) + 37 : 37), "%s%8.8x-%4.4hx-4%3.3hx-%4.4hx-%4.4hx%8.8x", prefix ? prefix : SOAP_STR_EOS, r1, (short)(r2 >> 16), (short)(((short)r2 >> 4) & 0x0FFF), (short)(((short)(r3 >> 16) & 0x3FFF) | 0x8000), (short)r3, r4);
   return soap->tmpbuf;
 }

References soap::buf, endif(), NULL, soap_random, SOAP_SNPRINTF, SOAP_STR_EOS, and soap::tmpbuf.

◆ soap_ready()

SOAP_FMAC1 int SOAP_FMAC2 soap_ready ( struct soap * soap )

Definition at line 6968 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEAN
   int r;
   if (!soap_valid_socket(soap->socket))
     return SOAP_OK; /* OK when no socket! */
   r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, 0);
   if (r > 0 && (r & SOAP_TCP_SELECT_ERR))
     r = -1;
   if (r < 0 && soap_socket_errno != SOAP_EINTR)
     return soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_ready()", SOAP_TCP_ERROR);
   if (r > 0)
   {
     char t;
 #ifdef WITH_OPENSSL
     if ((soap->imode & SOAP_ENC_SSL) && soap->ssl)
     {
       if (SSL_peek(soap->ssl, &t, 1) > 0)
         return SOAP_OK;
     }
     else
 #endif
     {
       if (recv(soap->socket, &t, 1, MSG_PEEK) > 0)
         return SOAP_OK;
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_ready: other end not ready to send on socket=%d select=%d\n", (int)soap->socket, r));
   return SOAP_EOF;
 #else
   (void)soap;
   return SOAP_OK;
 #endif
 }

References DBGLOG, soap::imode, SOAP_EINTR, SOAP_ENC_SSL, SOAP_EOF, SOAP_OK, soap_set_receiver_error(), soap_socket_errno, SOAP_TCP_ERROR, SOAP_TCP_SELECT_ERR, SOAP_TCP_SELECT_RCV, soap_valid_socket, soap::socket, soap::ssl, tcp_error(), tcp_select(), and TEST().

◆ soap_receiver_fault()

SOAP_FMAC1 int SOAP_FMAC2 soap_receiver_fault	(	struct soap *	soap,
		const char *	faultstring,
		const char *	faultdetailXML
	)

Definition at line 22646 of file stdsoap2.cpp.

 {
   return soap_receiver_fault_subcode(soap, NULL, faultstring, faultdetailXML);
 }

References NULL, and soap_receiver_fault_subcode().

◆ soap_receiver_fault_subcode()

SOAP_FMAC1 int SOAP_FMAC2 soap_receiver_fault_subcode	(	struct soap *	soap,
		const char *	faultsubcodeQName,
		const char *	faultstring,
		const char *	faultdetailXML
	)

Definition at line 22656 of file stdsoap2.cpp.

 {
   return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : soap->version == 1 ? "SOAP-ENV:Server" : "is internal", faultsubcodeQName, faultstring, faultdetailXML);
 }

References soap_copy_fault(), and soap::version.

Referenced by soap_receiver_fault().

◆ soap_recv()

SOAP_FMAC1 int SOAP_FMAC2 soap_recv ( struct soap * soap )

Definition at line 1595 of file stdsoap2.cpp.

 {
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_ENC_DIME))
   {
     if (soap->dime.buflen)
     {
       char *s;
       int i;
       unsigned char tmp[12];
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME hdr for chunked SOAP in DIME is in buffer\n"));
       soap->buflen = soap->dime.buflen;
       soap->dime.buflen = 0;
       soap->dime.chunksize = 0;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skip padding (%ld bytes)\n", -(long)soap->dime.size&3));
       for (i = -(long)soap->dime.size&3; i > 0; i--)
       {
         soap->bufidx++;
         if (soap->bufidx >= soap->buflen)
           if (soap_recv_raw(soap))
             return EOF;
       }
       if (!(soap->dime.flags & SOAP_DIME_CF))
         return SOAP_OK;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME hdr for next SOAP in DIME chunk\n"));
       s = (char*)tmp;
       for (i = 12; i > 0; i--)
       {
         *s++ = soap->buf[soap->bufidx++];
         if (soap->bufidx >= soap->buflen)
           if (soap_recv_raw(soap))
             return EOF;
       }
       if ((tmp[0] & 0xF8) != SOAP_DIME_VERSION)
         return soap->error = SOAP_DIME_MISMATCH;
       soap->dime.flags = (tmp[0] & 0x7) | (tmp[1] & 0xF0);
       soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]);
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get SOAP in DIME chunk (%u bytes)\n", (unsigned int)soap->dime.size));
       soap->dime.chunksize = soap->dime.size;
       if (soap->buflen - soap->bufidx >= soap->dime.size)
       {
         if ((soap->dime.flags & SOAP_DIME_ME))
         {
           soap->mode &= ~SOAP_ENC_DIME;
         }
         else
         {
           soap->dime.buflen = soap->buflen;
           soap->buflen = soap->bufidx + soap->dime.chunksize;
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked SOAP in DIME (%u bytes buffered)\n", (unsigned int)soap->buflen));
         }
       }
       else
       {
         soap->dime.chunksize -= soap->buflen - soap->bufidx;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked SOAP in DIME (%u bytes in chunk left)\n", (unsigned int)soap->dime.chunksize));
       }
       return SOAP_OK;
     }
     if (soap->dime.chunksize)
     {
       if (soap_recv_raw(soap))
         return EOF;
       if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
       {
         if ((soap->dime.flags & SOAP_DIME_ME))
         {
           soap->dime.chunksize = 0;
           soap->mode &= ~SOAP_ENC_DIME;
         }
         else
         {
           soap->dime.buflen = soap->buflen;
           soap->buflen = soap->bufidx + soap->dime.chunksize;
           soap->dime.chunksize = 0;
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked SOAP in DIME (%u bytes buffered)\n", (unsigned int)soap->buflen));
         }
       }
       else
       {
         soap->dime.chunksize -= soap->buflen - soap->bufidx;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked SOAP in DIME (%u bytes in chunk left)\n", (unsigned int)soap->dime.chunksize));
       }
       return SOAP_OK;
     }
   }
   if (soap->ffilterrecv)
   {
     int err;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Filter recverror = %d bufidx = %lu buflen = %lu\n", soap->recverror, (unsigned long)soap->bufidx, (unsigned long)soap->buflen));
     if (soap->recverror)
     {
       soap->bufidx = soap->buflen = 0;
     }
     else
     {
       soap->bufidx = soap->buflen = 0;
       err = soap->ffilterrecv(soap, soap->buf, &soap->buflen, sizeof(soap->buf));
       if (err)
       {
         if (err == SOAP_EOF)
           return SOAP_EOF;
         return soap->error = err;
       }
       if (soap->buflen)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Filtered output continued %lu bytes\n", (unsigned long)soap->buflen));
         return SOAP_OK;
       }
       soap->recverror = soap_recv_raw(soap);
       soap->buflen -= soap->bufidx; /* chunked may set bufidx > 0 to skip hex chunk length */
     }
     while (soap->ffilterrecv)
     {
       err = soap->ffilterrecv(soap, soap->buf + soap->bufidx, &soap->buflen, sizeof(soap->buf) - soap->bufidx);
       if (err)
       {
         if (err == SOAP_EOF)
           return SOAP_EOF;
         return soap->error = err;
       }
       if (soap->buflen)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Filtered output %lu bytes\n", (unsigned long)soap->buflen));
         soap->buflen += soap->bufidx;
         return SOAP_OK;
       }
       if (soap->recverror)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Returning postponed error %d\n", soap->recverror));
         return soap->recverror;
       }
       soap->recverror = soap_recv_raw(soap);
       soap->buflen -= soap->bufidx; /* chunked may set bufidx > 0 to skip hex chunk length */
     }
   }
   return soap->recverror = soap_recv_raw(soap);
 #else
   return soap_recv_raw(soap);
 #endif
 }

References soap::buf, soap::bufidx, soap_dime::buflen, soap::buflen, soap_dime::chunksize, DBGLOG, soap::dime, soap::error, soap::ffilterrecv, soap_dime::flags, soap::mode, soap::recverror, soap_dime::size, SOAP_DIME_CF, SOAP_DIME_ME, SOAP_DIME_MISMATCH, SOAP_DIME_VERSION, SOAP_ENC_DIME, SOAP_EOF, SOAP_OK, soap_recv_raw(), and TEST().

Referenced by soap_getdime().

◆ soap_recv_empty_response()

SOAP_FMAC1 int SOAP_FMAC2 soap_recv_empty_response ( struct soap * soap )

Definition at line 22446 of file stdsoap2.cpp.

 {
   soap->error = SOAP_OK;
   if (!(soap->omode & SOAP_IO_UDP) && !(soap->omode & SOAP_ENC_PLAIN))
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Receiving empty response\n"));
     if (soap_begin_recv(soap) == SOAP_OK)
     {
       if (soap_http_skip_body(soap) || soap_end_recv(soap))
         return soap_closesock(soap);
     }
     else if (soap->error == 200 || soap->error == 201 || soap->error == 202)
     {
       soap->error = SOAP_OK;
     }
   }
 #ifndef WITH_LEANER
   else if ((soap->fprepareinitrecv && (soap->error = soap->fprepareinitrecv(soap)))
         || (soap->fpreparefinalrecv && (soap->error = soap->fpreparefinalrecv(soap))))
   {
     return soap->error;
   }
 #endif
   return soap_closesock(soap);
 }

References DBGLOG, soap::error, soap::fpreparefinalrecv, soap::fprepareinitrecv, soap::omode, soap_begin_recv(), soap_closesock(), SOAP_ENC_PLAIN, soap_end_recv(), soap_http_skip_body(), SOAP_IO_UDP, SOAP_OK, and TEST().

Referenced by soap_DELETE(), soap_PATCH__QName(), soap_PATCH_byte(), soap_PATCH_int(), soap_PATCH_ns1__executeCommand(), soap_PATCH_ns1__executeCommandResponse(), soap_PATCH_SOAP_ENV__Code(), soap_PATCH_SOAP_ENV__Detail(), soap_PATCH_SOAP_ENV__Fault(), soap_PATCH_SOAP_ENV__Header(), soap_PATCH_SOAP_ENV__Reason(), soap_PATCH_string(), soap_PUT__QName(), soap_PUT_byte(), soap_PUT_int(), soap_PUT_ns1__executeCommand(), soap_PUT_ns1__executeCommandResponse(), soap_PUT_SOAP_ENV__Code(), soap_PUT_SOAP_ENV__Detail(), soap_PUT_SOAP_ENV__Fault(), soap_PUT_SOAP_ENV__Header(), soap_PUT_SOAP_ENV__Reason(), and soap_PUT_string().

◆ soap_recv_fault()

SOAP_FMAC1 int SOAP_FMAC2 soap_recv_fault	(	struct soap *	soap,
		int	check
	)

Definition at line 22324 of file stdsoap2.cpp.

 {
   int status = soap->status;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Check (%d) if receiving SOAP Fault (status = %d)\n", check, status));
   if (!check)
   {
     /* try getfault when no tag or tag mismatched at level 2, otherwise close and return SOAP_TAG_MISMATCH or HTTP error code */
     if (soap->error != SOAP_NO_TAG && (soap->error != SOAP_TAG_MISMATCH || soap->level != 2))
     {
       if (soap->error == SOAP_TAG_MISMATCH && soap->level == 0)
       {
         soap->error = SOAP_OK;
         if (!soap_element_begin_in(soap, "fault", 0, NULL))
         {
           char *s = NULL, *d = NULL;
           (void)soap_instring(soap, "reason", &s, NULL, 0, 1, 0, -1, NULL);
           (void)soap_inliteral(soap, "detail", &d);
           if (!soap_element_end_in(soap, "fault") && !soap_end_recv(soap))
           {
             *soap_faultstring(soap) = s;
             if (d && *d)
               *soap_faultdetail(soap) = d;
             if (status)
               soap->error = status;
             else
               soap->error = SOAP_FAULT;
             soap_set_fault(soap);
             return soap_closesock(soap);
           }
         }
         soap->error = SOAP_TAG_MISMATCH;
       }
       if (status && (status < 200 || status > 299))
         soap->error = status;
       return soap_closesock(soap);
     }
   }
   soap->error = SOAP_OK;
   if (soap_getfault(soap))
   {
     /* if check>0 and no SOAP Fault is present and no HTTP error then just return to parse request */
     if (check
      && (status == 0 || (status >= 200 && status <= 299))
      && ((soap->error == SOAP_TAG_MISMATCH && soap->level == 2) || soap->error == SOAP_NO_TAG))
       return soap->error = SOAP_OK;
     /* if check=0 and empty SOAP Body and encodingStyle is NULL and no HTTP error then just return */
     if (!check
      && (status == 0 || (status >= 200 && status <= 299))
      && !soap->encodingStyle
      && (soap->error == SOAP_NO_TAG && soap->level <= 2))
       return soap->error = SOAP_OK;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: soap_get_soapfault() failed with error %d at level %u tag '%s'\n", soap->error, soap->level, soap->tag));
     *soap_faultcode(soap) = (soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client");
     if (status)
       soap->error = status;
     else
       soap->error = status = SOAP_NO_DATA;
     soap_set_fault(soap);
   }
   else
   {
     const char *s = *soap_faultcode(soap);
     if (!soap_match_tag(soap, s, "SOAP-ENV:Server")
      || !soap_match_tag(soap, s, "SOAP-ENV:Receiver"))
     {
       status = SOAP_SVR_FAULT;
     }
     else if (!soap_match_tag(soap, s, "SOAP-ENV:Client")
           || !soap_match_tag(soap, s, "SOAP-ENV:Sender"))
     {
       status = SOAP_CLI_FAULT;
     }
     else if (!soap_match_tag(soap, s, "SOAP-ENV:MustUnderstand"))
     {
       status = SOAP_MUSTUNDERSTAND;
     }
     else if (!soap_match_tag(soap, s, "SOAP-ENV:VersionMismatch"))
     {
       status = SOAP_VERSIONMISMATCH;
     }
     else
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Received SOAP Fault code %s\n", s));
       status = SOAP_FAULT;
     }
     if (!soap_body_end_in(soap))
       soap_envelope_end_in(soap);
   }
   (void)soap_end_recv(soap);
   soap->error = status;
   return soap_closesock(soap);
 }

References mpq::d, DBGLOG, soap::encodingStyle, soap::error, soap::level, NULL, soap_body_end_in(), SOAP_CLI_FAULT, soap_closesock(), soap_element_begin_in(), soap_element_end_in(), soap_end_recv(), soap_envelope_end_in(), SOAP_FAULT, soap_faultcode(), soap_faultdetail(), soap_faultstring(), soap_getfault(), soap_inliteral(), soap_instring(), soap_match_tag(), SOAP_MUSTUNDERSTAND, SOAP_NO_DATA, SOAP_NO_TAG, SOAP_OK, soap_set_fault(), SOAP_SVR_FAULT, SOAP_TAG_MISMATCH, SOAP_VERSIONMISMATCH, soap::status, soap::tag, TEST(), and soap::version.

◆ soap_recv_header()

SOAP_FMAC1 int SOAP_FMAC2 soap_recv_header ( struct soap * soap )

Definition at line 21125 of file stdsoap2.cpp.

 {
   if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH)
     soap->error = SOAP_OK;
   if (soap->error == SOAP_OK && soap->fheader)
     soap->error = soap->fheader(soap);
   return soap->error;
 }

References soap::error, soap::fheader, soap_getheader(), SOAP_OK, and SOAP_TAG_MISMATCH.

Referenced by soap_begin_serve().

◆ soap_recv_mime_attachment()

SOAP_FMAC1 struct soap_multipart* SOAP_FMAC2 soap_recv_mime_attachment	(	struct soap *	soap,
		void *	handle
	)

Definition at line 19700 of file stdsoap2.cpp.

 {
   soap_wchar c = 0;
   size_t i, m = 0;
   char *s, *t = NULL;
   struct soap_multipart *content;
   short flag = 0;
   if (!(soap->mode & SOAP_ENC_MIME))
     goto post_check_exit;
   content = soap->mime.last;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get MIME (%p)\n", (void*)content));
   if (!content)
   {
     if (soap_getmimehdr(soap))
       goto post_check_exit;
     content = soap->mime.last;
   }
   else if (content != soap->mime.first)
   {
     if (soap->fmimewriteopen && ((content->ptr = (char*)soap->fmimewriteopen(soap, (void*)handle, content->id, content->type, content->description, content->encoding)) != NULL || soap->error))
     {
       if (!content->ptr)
         goto post_check_exit;
     }
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Parsing MIME content id='%s' type='%s'\n", content->id ? content->id : SOAP_STR_EOS, content->type ? content->type : SOAP_STR_EOS));
   if (!content->ptr && soap_alloc_block(soap) == NULL)
   {
     soap->error = SOAP_EOM;
     goto post_check_exit;
   }
   for (;;)
   {
     if (content->ptr)
     {
       s = soap->tmpbuf;
     }
     else
     {
       s = (char*)soap_push_block(soap, NULL, sizeof(soap->tmpbuf));
       if (!s)
       {
         soap->error = SOAP_EOM;
         goto post_check_exit;
       }
     }
     for (i = 0; i < sizeof(soap->tmpbuf); i++)
     {
       if (m > 0)
       {
         *s++ = *t++;
         m--;
       }
       else
       {
         if (!flag)
         {
           c = soap_getchar(soap);
           if ((int)c == EOF)
           {
             if (content->ptr && soap->fmimewriteclose)
               soap->fmimewriteclose(soap, (void*)content->ptr);
             soap->error = SOAP_CHK_EOF;
             goto post_check_exit;
           }
         }
         if (flag || c == '\r')
         {
           memset((void*)soap->msgbuf, 0, sizeof(soap->msgbuf));
           soap_strcpy(soap->msgbuf, sizeof(soap->msgbuf), "\n--");
           if (soap->mime.boundary)
           {
             if (soap_strncat(soap->msgbuf, sizeof(soap->msgbuf), soap->mime.boundary, sizeof(soap->msgbuf) - 4))
             {
               soap->error = SOAP_MIME_ERROR;
               goto post_check_exit;
             }
           }
           t = soap->msgbuf;
           do
           {
             c = soap_getchar(soap);
           } while (c == *t++);
           if ((int)c == EOF)
           {
             if (content->ptr && soap->fmimewriteclose)
               soap->fmimewriteclose(soap, (void*)content->ptr);
             soap->error = SOAP_CHK_EOF;
             goto post_check_exit;
           }
           if (!*--t)
             goto end;
           *t = (char)c;
           flag = (c == '\r');
           m = t - soap->msgbuf + 1 - flag;
           t = soap->msgbuf;
           c = '\r';
         }
         *s++ = (char)c;
       }
     }
     if (content->ptr && soap->fmimewrite)
     {
       soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i);
       if (soap->error)
         break;
     }
   }
 end:
   if (content->ptr)
   {
     if (!soap->error && soap->fmimewrite)
       soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i);
     if (soap->fmimewriteclose)
       soap->fmimewriteclose(soap, (void*)content->ptr);
     if (soap->error)
       goto post_check_exit;
   }
   else
   {
     *s = '\0'; /* make 0-terminated, just in case even though this is binary data */
     content->size = soap_size_block(soap, NULL, i + 1) - 1; /* last block with '\0' */
     content->ptr = soap_save_block(soap, NULL, NULL, 0);
   }
   soap_resolve_attachment(soap, content);
   if (c == '-' && soap_getchar(soap) == '-')
   {
     soap->mode &= ~SOAP_ENC_MIME;
     if ((soap->mode & SOAP_MIME_POSTCHECK))
     {
       if (soap_end_recv(soap))
         goto post_check_exit;
       if (soap->keep_alive == -2) /* special case to keep alive */
         soap->keep_alive = 0;
       soap_closesock(soap);
     }
   }
   else
   {
     while (c != '\r' && (int)c != EOF && soap_coblank(c))
       c = soap_getchar(soap);
     if (c != '\r' || soap_getchar(soap) != '\n')
     {
       soap->error = SOAP_MIME_ERROR;
       goto post_check_exit;
     }
     if (soap_getmimehdr(soap))
       goto post_check_exit;
   }
   return content;
 post_check_exit:
   if ((soap->mode & SOAP_MIME_POSTCHECK))
   {
     if (soap->keep_alive == -2) /* special case to keep alive */
       soap->keep_alive = 0;
     soap_closesock(soap);
   }
   return NULL;
 }

References soap_mime::boundary, mpq::c, DBGLOG, soap_multipart::description, soap_multipart::encoding, soap::error, soap_mime::first, soap::fmimewrite, soap::fmimewriteclose, soap::fmimewriteopen, soap_multipart::id, soap::keep_alive, soap_mime::last, memset, soap::mime, soap::mode, soap::msgbuf, NULL, soap_multipart::ptr, soap_multipart::size, soap_alloc_block(), SOAP_CHK_EOF, soap_closesock(), soap_coblank, SOAP_ENC_MIME, soap_end_recv(), SOAP_EOM, soap_getchar(), soap_getmimehdr(), SOAP_MIME_ERROR, SOAP_MIME_POSTCHECK, soap_push_block(), soap_resolve_attachment(), soap_save_block(), soap_size_block(), SOAP_STR_EOS, soap_strcpy, soap_strncat(), TEST(), soap::tmpbuf, and soap_multipart::type.

Referenced by soap_begin_recv(), soap_check_mime_attachments(), and soap_getmime().

◆ soap_recv_raw()

SOAP_FMAC1 int SOAP_FMAC2 soap_recv_raw ( struct soap * soap )

Definition at line 1353 of file stdsoap2.cpp.

 {
   size_t ret;
 #if !defined(WITH_LEANER) || defined(WITH_ZLIB)
   int r;
 #endif
 #ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && soap->d_stream)
   {
     if (soap->d_stream->next_out == Z_NULL)
     {
       soap->bufidx = soap->buflen = 0;
       return EOF;
     }
     if (soap->d_stream->avail_in || !soap->d_stream->avail_out)
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflating\n"));
       soap->d_stream->next_out = (Byte*)soap->buf;
       soap->d_stream->avail_out = sizeof(soap->buf);
       r = inflate(soap->d_stream, Z_NO_FLUSH);
       if (r == Z_NEED_DICT && soap->z_dict)
         r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
       if (r == Z_OK || r == Z_STREAM_END)
       {
         soap->bufidx = 0;
         ret = soap->buflen = sizeof(soap->buf) - soap->d_stream->avail_out;
         if (soap->zlib_in == SOAP_ZLIB_GZIP)
           soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)ret);
         if (r == Z_STREAM_END)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
           soap->d_stream->next_out = Z_NULL;
         }
         if (ret)
         {
           if (soap->count + ret < soap->count)
             return soap->error = SOAP_EOF;
           soap->count += ret;
           if (soap->recv_maxlength && soap->count > soap->recv_maxlength)
             return soap->error = SOAP_EOF;
           soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
           if (soap->count > SOAP_MAXINFLATESIZE && soap->z_ratio_in < SOAP_MINDEFLATERATIO)
           {
             soap->d_stream->msg = (char*)"caught SOAP_MINDEFLATERATIO explosive decompression guard (remedy: increase SOAP_MAXINFLATESIZE and/or decrease SOAP_MINDEFLATERATIO)";
             return soap->error = SOAP_ZLIB_ERROR;
           }
           DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
           DBGMSG(RECV, soap->buf, ret);
           DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n----\n"));
 #ifndef WITH_LEANER
           if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)) != SOAP_OK)
             return soap->error = r;
 #endif
           return SOAP_OK;
         }
       }
       else if (r != Z_BUF_ERROR)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
         soap->d_stream->next_out = Z_NULL;
         return soap->error = SOAP_ZLIB_ERROR;
       }
     }
 zlib_again:
     if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK && !soap->chunksize)
     {
       (void)soap_memcpy((void*)soap->buf, sizeof(soap->buf), (const void*)soap->z_buf, sizeof(soap->buf));
       soap->buflen = soap->z_buflen;
     }
     DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- compressed ----\n"));
   }
 #endif
 #ifndef WITH_NOHTTP
   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) /* read HTTP chunked transfer */
   {
     for (;;)
     {
       soap_wchar c;
       char *t, tmp[17];
       if (soap->chunksize)
       {
         soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > sizeof(soap->buf) ? sizeof(soap->buf) : soap->chunksize);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret));
         DBGMSG(RECV, soap->buf, ret);
         soap->bufidx = 0;
         if (!ret)
         {
           soap->ahead = EOF;
           return EOF;
         }
         soap->chunksize -= ret;
         break;
       }
       if (!soap->chunkbuflen)
       {
         soap->chunkbuflen = ret = soap->frecv(soap, soap->buf, sizeof(soap->buf));
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes (chunked) from socket=%d\n", (unsigned int)ret, (int)soap->socket));
         DBGMSG(RECV, soap->buf, ret);
         soap->bufidx = 0;
         if (!ret)
         {
           soap->ahead = EOF;
           return EOF;
         }
       }
       else
       {
         soap->bufidx = soap->buflen;
       }
       soap->buflen = soap->chunkbuflen;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (idx=%u len=%u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen));
       while (!soap_isxdigit((int)(c = soap_getchunkchar(soap))))
       {
         if ((int)c == EOF)
         {
           soap->ahead = EOF;
           return EOF;
         }
       }
       t = tmp;
       do
       {
         *t++ = (char)c;
       } while (soap_isxdigit((int)(c = soap_getchunkchar(soap))) && (size_t)(t - tmp) < sizeof(tmp)-1);
       while ((int)c != EOF && c != '\n')
         c = soap_getchunkchar(soap);
       if ((int)c == EOF)
       {
         soap->ahead = EOF;
         return EOF;
       }
       *t = '\0';
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunk size = %s (hex)\n", tmp));
       soap->chunksize = (size_t)soap_strtoul(tmp, &t, 16);
       if (!soap->chunksize)
       {
         soap->bufidx = soap->buflen = soap->chunkbuflen = 0;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of chunked message\n"));
         ret = 0;
         soap->ahead = EOF;
         break;
       }
       soap->buflen = soap->bufidx + soap->chunksize;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to idx=%u len=%u (%s)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen, tmp));
       if (soap->buflen > soap->chunkbuflen)
       {
         soap->buflen = soap->chunkbuflen;
         soap->chunksize -= soap->buflen - soap->bufidx;
         soap->chunkbuflen = 0;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%u bytes left)\n", (unsigned int)(soap->buflen - soap->bufidx)));
       }
       else if (soap->chunkbuflen)
       {
         soap->chunksize = 0;
       }
       ret = soap->buflen - soap->bufidx;
       if (ret)
         break;
     }
   }
   else
 #endif
   {
     soap->bufidx = 0;
     soap->buflen = ret = soap->frecv(soap, soap->buf, sizeof(soap->buf));
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket=%d/fd=%d\n", (unsigned int)ret, (int)soap->socket, soap->recvfd));
     DBGMSG(RECV, soap->buf, ret);
   }
 #ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB))
   {
     (void)soap_memcpy((void*)soap->z_buf, sizeof(soap->buf), (const void*)soap->buf, sizeof(soap->buf));
     soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
     soap->d_stream->avail_in = (unsigned int)ret;
     soap->d_stream->next_out = (Byte*)soap->buf;
     soap->d_stream->avail_out = sizeof(soap->buf);
     r = inflate(soap->d_stream, Z_NO_FLUSH);
     if (r == Z_NEED_DICT && soap->z_dict)
       r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
     if (r == Z_OK || r == Z_STREAM_END)
     {
       soap->bufidx = 0;
       soap->z_buflen = soap->buflen;
       soap->buflen = sizeof(soap->buf) - soap->d_stream->avail_out;
       if (soap->zlib_in == SOAP_ZLIB_GZIP)
         soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen);
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)soap->buflen));
       if (ret && !soap->buflen && r != Z_STREAM_END)
         goto zlib_again;
       ret = soap->buflen;
       if (r == Z_STREAM_END)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
         soap->d_stream->next_out = Z_NULL;
       }
       soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
       if (soap->count + ret > SOAP_MAXINFLATESIZE && soap->z_ratio_in < SOAP_MINDEFLATERATIO)
       {
         soap->d_stream->msg = (char*)"caught SOAP_MINDEFLATERATIO explosive decompression guard (remedy: increase SOAP_MAXINFLATESIZE and/or decrease SOAP_MINDEFLATERATIO)";
         return soap->error = SOAP_ZLIB_ERROR;
       }
       DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
       DBGMSG(RECV, soap->buf, ret);
 #ifndef WITH_LEANER
       if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)) != SOAP_OK)
         return soap->error = r;
 #endif
     }
     else
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
       soap->d_stream->next_out = Z_NULL;
       return soap->error = SOAP_ZLIB_ERROR;
     }
   }
 #endif
 #ifndef WITH_LEANER
   if (soap->fpreparerecv
 #ifdef WITH_ZLIB
    && soap->zlib_in == SOAP_ZLIB_NONE
 #endif
    && (r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, ret)))
     return soap->error = r;
 #endif
   if (ret)
   {
     if (soap->count + ret < soap->count)
       return EOF;
     soap->count += ret;
     if (soap->recv_maxlength && soap->count > soap->recv_maxlength)
       return EOF;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read count=" SOAP_ULONG_FORMAT " (+%lu)\n", soap->count, (unsigned long)ret));
     return SOAP_OK;
   }
   return EOF;
 }

References soap::ahead, soap::buf, soap::bufidx, soap::buflen, mpq::c, soap::chunkbuflen, soap::chunksize, count(), soap::count, crc32(), soap::d_stream, DBGLOG, DBGMSG, endif(), soap::error, soap::fpreparerecv, soap::frecv, if(), inflate(), inflateSetDictionary(), soap::mode, soap::recv_maxlength, soap::recvfd, ret, SOAP_ENC_ZLIB, SOAP_EOF, soap_getchunkchar(), SOAP_IO, SOAP_IO_CHUNK, soap_isxdigit(), SOAP_MAXINFLATESIZE, soap_memcpy, SOAP_MINDEFLATERATIO, SOAP_OK, SOAP_STR_EOS, soap_strtoul, SOAP_ULONG_FORMAT, SOAP_ZLIB_ERROR, SOAP_ZLIB_GZIP, SOAP_ZLIB_NONE, soap::socket, TEST(), soap::z_buf, Z_BUF_ERROR, soap::z_buflen, soap::z_crc, soap::z_dict, soap::z_dict_len, Z_NEED_DICT, Z_NO_FLUSH, Z_NULL, Z_OK, soap::z_ratio_in, Z_STREAM_END, and soap::zlib_in.

Referenced by soap_end_recv(), and soap_recv().

◆ soap_reference()

SOAP_FMAC1 int SOAP_FMAC2 soap_reference	(	struct soap *	soap,
		const void *	p,
		int	t
	)

Definition at line 10031 of file stdsoap2.cpp.

 {
   struct soap_plist *pp;
   if (!p || (!soap->encodingStyle && !(soap->omode & (SOAP_ENC_DIME | SOAP_ENC_MIME | SOAP_ENC_MTOM | SOAP_XML_GRAPH))) || (soap->omode & SOAP_XML_TREE))
     return 1;
   if (soap_pointer_lookup(soap, p, t, &pp))
   {
     if (pp->mark1 == 0)
     {
       pp->mark1 = 2;
       pp->mark2 = 2;
     }
   }
   else if (!soap_pointer_enter(soap, p, NULL, 0, t, &pp))
   {
     return 1;
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reference %p type=%d (%d %d)\n", p, t, (int)pp->mark1, (int)pp->mark2));
   return pp->mark1;
 }

References DBGLOG, soap::encodingStyle, soap_plist::mark1, soap_plist::mark2, NULL, soap::omode, SOAP_ENC_DIME, SOAP_ENC_MIME, SOAP_ENC_MTOM, soap_pointer_enter(), soap_pointer_lookup(), SOAP_XML_GRAPH, SOAP_XML_TREE, and TEST().

Referenced by soap_serialize__QName(), soap_serialize_PointerToSOAP_ENV__Code(), soap_serialize_PointerToSOAP_ENV__Detail(), soap_serialize_PointerToSOAP_ENV__Reason(), soap_serialize_PointerTostring(), and soap_serialize_string().

◆ soap_register_plugin_arg()

SOAP_FMAC1 int SOAP_FMAC2 soap_register_plugin_arg	(	struct soap *	soap,
		int()(struct soap , struct soap_plugin , void )	fcreate,
		void *	arg
	)

Definition at line 22856 of file stdsoap2.cpp.

 {
   struct soap_plugin *p;
   int err;
   p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin));
   if (!p)
     return soap->error = SOAP_EOM;
   p->id = NULL;
   p->data = NULL;
   p->fcopy = NULL;
   p->fdelete = NULL;
   err = fcreate(soap, p, arg);
   if (!err && p->fdelete && p->id)
   {
     if (!soap_lookup_plugin(soap, p->id))
     {
       p->next = soap->plugins;
       soap->plugins = p;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Registered '%s' plugin\n", p->id));
       return SOAP_OK;
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not register plugin '%s': plugin with the same ID already registered\n", p->id));
     SOAP_FREE(soap, p);
     return SOAP_OK;
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not register plugin '%s': plugin returned error %d or plugin ID not set or fdelete callback not set\n", p->id ? p->id : "plugin ID not set", err));
   SOAP_FREE(soap, p);
   soap->error = err ? err : SOAP_PLUGIN_ERROR;
   return soap->error;
 }

References arg(), soap_plugin::data, DBGLOG, soap::error, soap_plugin::fcopy, soap_plugin::fdelete, soap_plugin::id, soap_plugin::next, NULL, soap::plugins, SOAP_EOM, SOAP_FREE, soap_lookup_plugin(), SOAP_MALLOC, SOAP_OK, SOAP_PLUGIN_ERROR, and TEST().

◆ soap_resolve()

SOAP_FMAC1 int SOAP_FMAC2 soap_resolve ( struct soap * soap )

Definition at line 3089 of file stdsoap2.cpp.

 {
   int i;
   short flag;
   const char *id;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded refs\n"));
   for (i = 0; i < SOAP_IDHASH; i++)
   {
     struct soap_ilist *ip;
     for (ip = soap->iht[i]; ip; ip = ip->next)
     {
       if (ip->ptr)
       {
         void **q;
         struct soap_flist *fp, **fpp = &ip->flist;
         if (ip->spine)
           ip->spine[0] = ip->ptr;
         q = (void**)ip->link;
         ip->link = NULL;
         DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing link chain to resolve id='%s' type=%d\n", ip->id, ip->type));
         while (q)
         {
           void *p = *q;
           *q = ip->ptr;
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... link %p -> %p\n", (void*)q, ip->ptr));
           q = (void**)p;
         }
         while ((fp = *fpp))
         {
           if (fp->level > 0 && fp->finsert)
           {
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... insert type=%d link %p -> %p\n", fp->type, fp->ptr, ip->ptr));
             if (ip->spine && fp->level <= SOAP_MAXPTRS)
               fp->finsert(soap, ip->type, fp->type, fp->ptr, fp->index, &ip->spine[fp->level - 1], &ip->smart);
             else if (fp->level == 1)
               fp->finsert(soap, ip->type, fp->type, fp->ptr, fp->index, &ip->ptr, &ip->smart);
             else if (fp->level <= SOAP_MAXPTRS)
             {
               int i;
               ip->spine = (void**)soap_malloc(soap, SOAP_MAXPTRS * sizeof(void*));
               if (!ip->spine)
                 return soap->error = SOAP_EOM;
               ip->spine[0] = ip->ptr;
               for (i = 1; i < SOAP_MAXPTRS; i++)
                 ip->spine[i] = &ip->spine[i - 1];
               fp->finsert(soap, ip->type, fp->type, fp->ptr, fp->index, &ip->spine[fp->level - 1], &ip->smart);
             }
             *fpp = fp->next;
             SOAP_FREE(soap, fp);
           }
           else
             fpp = &fp->next;
         }
       }
       else if (*ip->id == '#')
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Missing id='%s'\n", ip->id));
         soap_strcpy(soap->id, sizeof(soap->id), ip->id + 1);
         return soap->error = SOAP_MISSING_ID;
       }
     }
   }
   do
   {
     flag = 0;
     id = NULL;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution phase\n"));
     for (i = 0; i < SOAP_IDHASH; i++)
     {
       struct soap_ilist *ip;
       for (ip = soap->iht[i]; ip; ip = ip->next)
       {
         if (ip->copy || ip->flist)
         {
           if (ip->ptr && !soap_has_copies(soap, (const char*)ip->ptr, (const char*)ip->ptr + ip->size))
           {
             struct soap_flist *fp;
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving id='%s' type=%d ptr=%p size=%lu ...\n", ip->id, ip->type, ip->ptr, (unsigned long)ip->size));
             if (ip->copy)
             {
               void *p, **q = (void**)ip->copy;
               DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing copy chain to resolve id='%s'\n", ip->id));
               ip->copy = NULL;
               do
               {
                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%u bytes)\n", ip->ptr, (void*)q, (unsigned int)ip->size));
                 p = *q;
                 (void)soap_memcpy((void*)q, ip->size, (const void*)ip->ptr, ip->size);
                 q = (void**)p;
               } while (q);
               flag = 1;
             }
             while ((fp = ip->flist))
             {
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data type=%d target type=%d location=%p level=%u id='%s'\n", ip->type, fp->type, ip->ptr, fp->level, ip->id));
               if (fp->level == 0)
               {
                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%lu bytes)\n", ip->ptr, fp->ptr, (unsigned long)ip->size));
                 if (fp->finsert)
                   fp->finsert(soap, ip->type, fp->type, fp->ptr, fp->index, ip->ptr, &ip->smart);
                 else
                   (void)soap_memcpy((void*)fp->ptr, ip->size, (const void*)ip->ptr, ip->size);
               }
               ip->flist = fp->next;
               SOAP_FREE(soap, fp);
               flag = 1;
             }
           }
           else if (*ip->id == '#')
             id = ip->id;
         }
       }
     }
   } while (flag);
   if (id)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution error: forwarded data for id='%s' could not be propagated, please report this problem to the gSOAP developers\n", id));
     return soap_id_nullify(soap, id);
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution done\n"));
   return SOAP_OK;
 }

References soap_ilist::copy, DBGLOG, soap::error, soap_flist::finsert, soap_ilist::flist, soap_ilist::id, soap::id, soap::iht, soap_flist::index, soap_flist::level, soap_ilist::link, soap_flist::next, soap_ilist::next, NULL, soap_flist::ptr, soap_ilist::ptr, soap_ilist::size, soap_ilist::smart, SOAP_EOM, SOAP_FREE, soap_has_copies(), soap_id_nullify(), SOAP_IDHASH, soap_malloc(), SOAP_MAXPTRS, soap_memcpy, SOAP_MISSING_ID, SOAP_OK, soap_strcpy, soap_ilist::spine, TEST(), soap_flist::type, and soap_ilist::type.

Referenced by soap_end_recv().

◆ soap_response()

SOAP_FMAC1 int SOAP_FMAC2 soap_response	(	struct soap *	soap,
		int	status
	)

Definition at line 8383 of file stdsoap2.cpp.

 {
   ULONG64 count;
   if (!(soap->omode & (SOAP_ENC_PLAIN | SOAP_IO_STORE /* this tests for chunking too */))
    && (status == SOAP_HTML || (status >= SOAP_FILE && status < SOAP_FILE + 600)))
     soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
   soap->status = status;
   count = soap_count_attachments(soap);
   if (soap_init_send(soap))
     return soap->error;
 #ifndef WITH_NOHTTP
   if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_PLAIN))
   {
     int k = soap->mode;
     soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
     if ((k & SOAP_IO) != SOAP_IO_FLUSH)
       soap->mode |= SOAP_IO_BUFFER;
     soap->error = soap->fresponse(soap, status, count);
     if (soap->error)
       return soap->error;
 #ifndef WITH_LEANER
     if ((k & SOAP_IO) == SOAP_IO_CHUNK)
     {
       if (soap_flush(soap))
         return soap->error;
     }
 #endif
     soap->mode = k;
   }
 #endif
 #ifndef WITH_LEANER
   if (soap_begin_attachments(soap))
     return soap->error;
 #endif
   return SOAP_OK;
 }

References count(), endif(), soap::error, soap::fresponse, soap::mode, soap::omode, soap_begin_attachments(), soap_count_attachments(), SOAP_ENC_PLAIN, SOAP_ENC_ZLIB, SOAP_FILE, soap_flush(), SOAP_HTML, soap_init_send(), SOAP_IO, SOAP_IO_BUFFER, SOAP_IO_CHUNK, SOAP_IO_FLUSH, SOAP_IO_STORE, SOAP_OK, soap::status, and ULONG64.

Referenced by soap_send_empty_response(), soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_retry()

SOAP_FMAC1 void SOAP_FMAC2 soap_retry ( struct soap * soap )

Definition at line 14975 of file stdsoap2.cpp.

 {
   soap->error = SOAP_OK;
   soap_revert(soap);
 }

References soap::error, SOAP_OK, and soap_revert().

Referenced by soap_xop_forward().

◆ soap_revert()

SOAP_FMAC1 void SOAP_FMAC2 soap_revert ( struct soap * soap )

Definition at line 14986 of file stdsoap2.cpp.

 {
   if (!soap->peeked)
   {
     soap->peeked = 1;
     if (soap->body)
       soap->level--;
   }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reverting to last element '%s' (level=%u)\n", soap->tag, soap->level));
 }

References soap::body, DBGLOG, soap::level, soap::peeked, soap::tag, and TEST().

Referenced by soap_in_PointerToSOAP_ENV__Code(), soap_in_PointerToSOAP_ENV__Detail(), soap_in_PointerToSOAP_ENV__Reason(), soap_in_PointerTostring(), soap_inbyte(), soap_indateTime(), soap_inint(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), soap_inunsignedShort(), soap_isnumeric(), and soap_retry().

◆ soap_s2base64()

SOAP_FMAC1 char* SOAP_FMAC2 soap_s2base64	(	struct soap *	soap,
		const unsigned char *	s,
		char *	t,
		int	n
	)

Definition at line 21586 of file stdsoap2.cpp.

 {
   int i;
   unsigned long m;
   char *p;
   if (!t)
     t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1);
   if (!t)
     return NULL;
   p = t;
   t[0] = '\0';
   if (!s)
     return p;
   for (; n > 2; n -= 3, s += 3)
   {
     m = s[0];
     m = (m << 8) | s[1];
     m = (m << 8) | s[2];
     for (i = 4; i > 0; m >>= 6)
       t[--i] = soap_base64o[m & 0x3F];
     t += 4;
   }
   t[0] = '\0';
   if (n > 0) /* 0 < n <= 2 implies that t[0..4] is allocated (base64 scaling formula) */
   {
     m = 0;
     for (i = 0; i < n; i++)
       m = (m << 8) | *s++;
     for (; i < 3; i++)
       m <<= 8;
     for (i = 4; i > 0; m >>= 6)
       t[--i] = soap_base64o[m & 0x3F];
     for (i = 3; i > n; i--)
       t[i] = '=';
     t[4] = '\0';
   }
   return p;
 }

References NULL, soap_base64o, and soap_malloc().

Referenced by http_post(), and soap_putbase64().

◆ soap_s2byte()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2byte	(	struct soap *	soap,
		const char *	s,
		char *	p
	)

Definition at line 16412 of file stdsoap2.cpp.

 {
   if (s)
   {
     long n;
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
     n = soap_strtol(s, &r, 10);
     if (s == r || *r || n < -128 || n > 127)
       soap->error = SOAP_TYPE;
     *p = (char)n;
   }
   return soap->error;
 }

References soap::error, SOAP_EMPTY, soap_strtol, and SOAP_TYPE.

Referenced by soap_inbyte().

◆ soap_s2char()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2char	(	struct soap *	soap,
		const char *	s,
		char **	t,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 17384 of file stdsoap2.cpp.

 {
   if (s)
   {
     const char *r = soap_string(soap, s, flag, minlen, maxlen, pattern);
     if (r && (*t = soap_strdup(soap, r)) == NULL)
       return soap->error = SOAP_EOM;
   }
   return soap->error;
 }

References soap::error, soap_attribute::flag, NULL, SOAP_EOM, soap_strdup(), and soap_string().

◆ soap_s2dateTime()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2dateTime	(	struct soap *	soap,
		const char *	s,
		time_t *	p
	)

Definition at line 18686 of file stdsoap2.cpp.

 {
   *p = 0;
   if (s)
   {
     char *t;
     unsigned long d;
     struct tm T;
     if (!*s)
       return soap->error = SOAP_EMPTY;
     memset((void*)&T, 0, sizeof(T));
     d = soap_strtoul(s, &t, 10);
     if (*t == '-')
     {
       /* YYYY-MM-DD */
       T.tm_year = (int)d;
       T.tm_mon = (int)soap_strtoul(t + 1, &t, 10);
       T.tm_mday = (int)soap_strtoul(t + 1, &t, 10);
     }
     else if (!(soap->mode & SOAP_XML_STRICT))
     {
       /* YYYYMMDD */
       T.tm_year = (int)(d / 10000);
       T.tm_mon = (int)(d / 100 % 100);
       T.tm_mday = (int)(d % 100);
     }
     else
     {
       return soap->error = SOAP_TYPE;
     }
     if (*t == 'T' || ((*t == 't' || *t == ' ') && !(soap->mode & SOAP_XML_STRICT)))
     {
       d = soap_strtoul(t + 1, &t, 10);
       if (*t == ':')
       {
         /* Thh:mm:ss */
         T.tm_hour = (int)d;
         T.tm_min = (int)soap_strtoul(t + 1, &t, 10);
         T.tm_sec = (int)soap_strtoul(t + 1, &t, 10);
       }
       else if (!(soap->mode & SOAP_XML_STRICT))
       {
         /* Thhmmss */
         T.tm_hour = (int)(d / 10000);
         T.tm_min = (int)(d / 100 % 100);
         T.tm_sec = (int)(d % 100);
       }
       else
       {
         return soap->error = SOAP_TYPE;
       }
     }
     if (T.tm_year == 1)
       T.tm_year = 70;
     else
       T.tm_year -= 1900;
     T.tm_mon--;
     if (*t == '.')
     {
       for (t++; *t; t++)
         if (*t < '0' || *t > '9')
           break;
     }
     if (*t == ' ' && !(soap->mode & SOAP_XML_STRICT))
       t++;
     if (*t)
     {
 #ifndef WITH_NOZONE
       if (*t == '+' || *t == '-')
       {
         int h, m;
         m = (int)soap_strtol(t, &t, 10);
         if (*t == ':')
         {
           /* +hh:mm */
           h = m;
           m = (int)soap_strtol(t + 1, &t, 10);
           if (h < 0)
             m = -m;
         }
         else if (!(soap->mode & SOAP_XML_STRICT))
         {
           /* +hhmm */
           h = m / 100;
           m = m % 100;
         }
         else
         {
           /* +hh */
           h = m;
           m = 0;
         }
         if (*t)
           return soap->error = SOAP_TYPE;
         T.tm_min -= m;
         T.tm_hour -= h;
         /* put hour and min in range */
         T.tm_hour += T.tm_min / 60;
         T.tm_min %= 60;
         if (T.tm_min < 0)
         {
           T.tm_min += 60;
           T.tm_hour--;
         }
         T.tm_mday += T.tm_hour / 24;
         T.tm_hour %= 24;
         if (T.tm_hour < 0)
         {
           T.tm_hour += 24;
           T.tm_mday--;
         }
         /* note: day of the month may be out of range, timegm() handles it */
       }
       else if (*t != 'Z')
       {
         return soap->error = SOAP_TYPE;
       }
 #endif
       *p = soap_timegm(&T);
     }
     else /* no UTC or timezone, so assume we got a localtime */
     {
       T.tm_isdst = -1;
       *p = mktime(&T);
     }
   }
   return soap->error;
 }

References mpq::d, soap::error, memset, soap::mode, SOAP_EMPTY, soap_strtol, soap_strtoul, soap_timegm(), SOAP_TYPE, and SOAP_XML_STRICT.

Referenced by soap_indateTime().

◆ soap_s2double()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2double	(	struct soap *	soap,
		const char *	s,
		double *	p
	)

Definition at line 16817 of file stdsoap2.cpp.

 {
   if (s)
   {
     if (!*s)
       return soap->error = SOAP_EMPTY;
     if (!soap_tag_cmp(s, "INF"))
     {
       *p = DBL_PINFTY;
     }
     else if (!soap_tag_cmp(s, "+INF"))
     {
       *p = DBL_PINFTY;
     }
     else if (!soap_tag_cmp(s, "-INF"))
     {
       *p = DBL_NINFTY;
     }
     else if (!soap_tag_cmp(s, "NaN"))
     {
       *p = DBL_NAN;
     }
     else
     {
 #if defined(WITH_C_LOCALE)
 # if defined(HAVE_STRTOD_L)
       char *r;
 #  ifdef WIN32
       *p = _strtod_l(s, &r, SOAP_LOCALE(soap));
 #  else
       *p = strtod_l(s, &r, SOAP_LOCALE(soap));
 #  endif
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_STRTOD)
       char *r;
       SOAP_LOCALE_T locale = uselocale(SOAP_LOCALE(soap));
       *p = strtod(s, &r);
       uselocale(locale);
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_SSCANF_L)
       SOAP_LOCALE_T locale = uselocale(SOAP_LOCALE(soap));
       if (sscanf_l(s, SOAP_LOCALE(soap), "%lf", p) != 1)
         soap->error = SOAP_TYPE;
       uselocale(locale);
 # else
       soap->error = SOAP_TYPE;
 # endif
 #elif defined(HAVE_STRTOD)
       char *r;
       *p = strtod(s, &r);
       if (*r)
         soap->error = SOAP_TYPE;
 #elif defined(HAVE_SSCANF)
       if (sscanf(s, "%lf", p) != 1)
         soap->error = SOAP_TYPE;
 #else
       soap->error = SOAP_TYPE;
 #endif
     }
   }
   return soap->error;
 }

References DBL_NAN, DBL_NINFTY, DBL_PINFTY, soap::error, SOAP_EMPTY, soap_tag_cmp(), and SOAP_TYPE.

Referenced by soap_indouble().

◆ soap_s2float()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2float	(	struct soap *	soap,
		const char *	s,
		float *	p
	)

Definition at line 16606 of file stdsoap2.cpp.

 {
   if (s)
   {
     if (!*s)
       return soap->error = SOAP_EMPTY;
     if (!soap_tag_cmp(s, "INF"))
     {
       *p = FLT_PINFTY;
     }
     else if (!soap_tag_cmp(s, "+INF"))
     {
       *p = FLT_PINFTY;
     }
     else if (!soap_tag_cmp(s, "-INF"))
     {
       *p = FLT_NINFTY;
     }
     else if (!soap_tag_cmp(s, "NaN"))
     {
       *p = FLT_NAN;
     }
     else
     {
 /* On some systems strtof requires -std=c99 or does not even link: so we try strtod first */
 #if defined(WITH_C_LOCALE)
 # if defined(HAVE_STRTOD_L)
       char *r;
 #  ifdef WIN32
       *p = (float)_strtod_l(s, &r, SOAP_LOCALE(soap));
 #  else
       *p = (float)strtod_l(s, &r, SOAP_LOCALE(soap));
 #  endif
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_STRTOF_L)
       char *r;
       *p = strtof_l((char*)s, &r, SOAP_LOCALE(soap));
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_SSCANF_L)
       double n;
       if (sscanf_l(s, SOAP_LOCALE(soap), "%lf", &n) != 1)
         soap->error = SOAP_TYPE;
       *p = (float)n;
 # elif defined(HAVE_STRTOD)
       char *r;
       SOAP_LOCALE_T locale = uselocale(SOAP_LOCALE(soap));
       *p = (float)strtod((char*)s, &r);
       uselocale(locale);
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_STRTOF)
       char *r;
       SOAP_LOCALE_T locale = uselocale(SOAP_LOCALE(soap));
       *p = strtof((char*)s, &r);
       uselocale(locale);
       if (*r)
         soap->error = SOAP_TYPE;
 # elif defined(HAVE_SSCANF)
       double n;
       SOAP_LOCALE_T locale = uselocale(SOAP_LOCALE(soap));
       if (sscanf(s, "%lf", &n) != 1)
         soap->error = SOAP_TYPE;
       uselocale(locale);
       *p = (float)n;
 # else
       soap->error = SOAP_TYPE;
 # endif
 #elif defined(HAVE_STRTOD)
       char *r;
       *p = (float)strtod(s, &r);
       if (*r)
         soap->error = SOAP_TYPE;
 #elif defined(HAVE_STRTOF)
       char *r;
       *p = strtof((char*)s, &r);
       if (*r)
         soap->error = SOAP_TYPE;
 #elif defined(HAVE_SSCANF)
       double n;
       if (sscanf(s, "%lf", &n) != 1)
         soap->error = SOAP_TYPE;
       *p = (float)n;
 #else
       soap->error = SOAP_TYPE;
 #endif
     }
   }
   return soap->error;
 }

References soap::error, FLT_NAN, FLT_NINFTY, FLT_PINFTY, SOAP_EMPTY, soap_tag_cmp(), and SOAP_TYPE.

Referenced by soap_infloat().

◆ soap_s2hex()

SOAP_FMAC1 char* SOAP_FMAC2 soap_s2hex	(	struct soap *	soap,
		const unsigned char *	s,
		char *	t,
		int	n
	)

Definition at line 21722 of file stdsoap2.cpp.

 {
   char *p;
   if (!t)
     t = (char*)soap_malloc(soap, 2 * n + 1);
   if (!t)
     return NULL;
   p = t;
   t[0] = '\0';
   if (s)
   {
     for (; n > 0; n--)
     {
       int m = *s++;
       *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0'));
       m &= 0x0F;
       *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0'));
     }
   }
   *t++ = '\0';
   return p;
 }

References NULL, and soap_malloc().

Referenced by soap_puthex().

◆ soap_s2int()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2int	(	struct soap *	soap,
		const char *	s,
		int *	p
	)

Definition at line 16117 of file stdsoap2.cpp.

 {
   if (s)
   {
     long n;
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     n = soap_strtol(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_LEAN
         || n != (int)n
 #endif
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
     )
       soap->error = SOAP_TYPE;
     *p = (int)n;
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtol, and SOAP_TYPE.

Referenced by soap_inint().

◆ soap_s2long()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2long	(	struct soap *	soap,
		const char *	s,
		long *	p
	)

Definition at line 16217 of file stdsoap2.cpp.

 {
   if (s)
   {
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     *p = soap_strtol(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
     )
       soap->error = SOAP_TYPE;
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtol, and SOAP_TYPE.

Referenced by soap_inlong().

◆ soap_s2LONG64()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2LONG64	(	struct soap *	soap,
		const char *	s,
		LONG64 *	p
	)

Definition at line 16312 of file stdsoap2.cpp.

 {
   if (s)
   {
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     *p = soap_strtoll(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
       )
       soap->error = SOAP_TYPE;
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtoll, and SOAP_TYPE.

Referenced by soap_inLONG64().

◆ soap_s2QName()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2QName	(	struct soap *	soap,
		const char *	s,
		char **	t,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 17521 of file stdsoap2.cpp.

 {
   *t = NULL;
   if (s)
   {
     const char *r = soap_QName(soap, s, minlen, maxlen, pattern);
     if (r && (*t = soap_strdup(soap, r)) == NULL)
       return soap->error = SOAP_EOM;
   }
   return soap->error;
 }

References soap::error, NULL, SOAP_EOM, soap_QName(), and soap_strdup().

Referenced by soap_string_in().

◆ soap_s2short()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2short	(	struct soap *	soap,
		const char *	s,
		short *	p
	)

Definition at line 16495 of file stdsoap2.cpp.

 {
   if (s)
   {
     long n;
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
     n = soap_strtol(s, &r, 10);
     if (s == r || *r || n < -32768 || n > 32767)
       soap->error = SOAP_TYPE;
     *p = (short)n;
   }
   return soap->error;
 }

References soap::error, SOAP_EMPTY, soap_strtol, and SOAP_TYPE.

Referenced by soap_inshort().

◆ soap_s2ULONG64()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2ULONG64	(	struct soap *	soap,
		const char *	s,
		ULONG64 *	p
	)

Definition at line 17308 of file stdsoap2.cpp.

 {
   if (s)
   {
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     *p = soap_strtoull(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
       )
       soap->error = SOAP_TYPE;
     if (*p > 0 && strchr(s, '-'))
       return soap->error = SOAP_TYPE;
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtoull, and SOAP_TYPE.

Referenced by soap_inULONG64().

◆ soap_s2unsignedByte()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedByte	(	struct soap *	soap,
		const char *	s,
		unsigned char *	p
	)

Definition at line 16943 of file stdsoap2.cpp.

 {
   if (s)
   {
     long n;
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
     n = soap_strtol(s, &r, 10);
     if (s == r || *r || n < 0 || n > 255)
       soap->error = SOAP_TYPE;
     *p = (unsigned char)n;
   }
   return soap->error;
 }

References soap::error, SOAP_EMPTY, soap_strtol, and SOAP_TYPE.

Referenced by soap_inunsignedByte().

◆ soap_s2unsignedInt()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedInt	(	struct soap *	soap,
		const char *	s,
		unsigned int *	p
	)

Definition at line 17110 of file stdsoap2.cpp.

 {
   if (s)
   {
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     *p = (unsigned int)soap_strtoul(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
     )
       soap->error = SOAP_TYPE;
 #ifdef HAVE_STRTOUL
     if (*p > 0 && strchr(s, '-'))
       return soap->error = SOAP_TYPE;
 #endif
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtoul, and SOAP_TYPE.

Referenced by soap_inunsignedInt().

◆ soap_s2unsignedLong()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedLong	(	struct soap *	soap,
		const char *	s,
		unsigned long *	p
	)

Definition at line 17209 of file stdsoap2.cpp.

 {
   if (s)
   {
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
     soap_reset_errno;
 #endif
 #endif
     *p = soap_strtoul(s, &r, 10);
     if (s == r || *r
 #ifndef WITH_NOIO
 #ifndef WITH_LEAN
         || soap_errno == SOAP_ERANGE
 #endif
 #endif
     )
       soap->error = SOAP_TYPE;
 #ifdef HAVE_STRTOUL
     if (*p > 0 && strchr(s, '-'))
       return soap->error = SOAP_TYPE;
 #endif
   }
   return soap->error;
 }

References endif(), soap::error, SOAP_EMPTY, SOAP_ERANGE, soap_errno, soap_reset_errno, soap_strtoul, and SOAP_TYPE.

Referenced by soap_inunsignedLong().

◆ soap_s2unsignedShort()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedShort	(	struct soap *	soap,
		const char *	s,
		unsigned short *	p
	)

Definition at line 17026 of file stdsoap2.cpp.

 {
   if (s)
   {
     long n;
     char *r;
     if (!*s)
       return soap->error = SOAP_EMPTY;
     n = soap_strtol(s, &r, 10);
     if (s == r || *r || n < 0 || n > 65535)
       soap->error = SOAP_TYPE;
     *p = (unsigned short)n;
   }
   return soap->error;
 }

References soap::error, SOAP_EMPTY, soap_strtol, and SOAP_TYPE.

Referenced by soap_inunsignedShort().

◆ soap_s2wchar()

SOAP_FMAC1 int SOAP_FMAC2 soap_s2wchar	(	struct soap *	soap,
		const char *	s,
		wchar_t **	t,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 17893 of file stdsoap2.cpp.

 {
   if (s)
   {
     const wchar_t *r = soap_wstring(soap, s, flag, minlen, maxlen, pattern);
     if (r && (*t = soap_wstrdup(soap, r)) == NULL)
       return soap->error = SOAP_EOM;
   }
   return soap->error;
 }

References soap::error, NULL, SOAP_EOM, soap_wstrdup(), and soap_wstring().

◆ soap_save_block()

SOAP_FMAC1 char* SOAP_FMAC2 soap_save_block	(	struct soap *	soap,
		struct soap_blist *	b,
		char *	p,
		int	flag
	)

Definition at line 3342 of file stdsoap2.cpp.

 {
   size_t n;
   char *q, *s;
   if (!b)
     b = soap->blist;
   if (b->size)
   {
     if (!p)
       p = (char*)soap_malloc(soap, b->size);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Save all %lu blocks in contiguous memory space of %u bytes (%p->%p)\n", (unsigned long)b->item, (unsigned int)b->size, (void*)b->head, (void*)p));
     if (p)
     {
       s = p;
       for (q = soap_first_block(soap, b); q; q = soap_next_block(soap, b))
       {
         n = soap_block_size(soap, b);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy %u bytes from %p to %p\n", (unsigned int)n, (void*)q, (void*)s));
         if (flag)
           soap_update_pointers(soap, s, q, n);
         (void)soap_memcpy((void*)s, n, (const void*)q, n);
         s += n;
       }
     }
     else
       soap->error = SOAP_EOM;
   }
   soap_end_block(soap, b);
   return p;
 }

References b, soap::blist, DBGLOG, soap::error, soap_block_size(), soap_end_block(), SOAP_EOM, soap_first_block(), soap_malloc(), soap_memcpy, soap_next_block(), soap_update_pointers(), and TEST().

Referenced by soap_end_send_flush(), soap_getdime(), soap_gethex(), soap_http_get_body_prefix(), soap_peek_element(), soap_QName(), soap_QName2s(), soap_recv_mime_attachment(), soap_string_in(), and soap_wstring_in().

◆ soap_send()

SOAP_FMAC1 int SOAP_FMAC2 soap_send	(	struct soap *	soap,
		const char *	s
	)

Definition at line 949 of file stdsoap2.cpp.

 {
   if (!s)
     return SOAP_OK;
   return soap_send_raw(soap, s, strlen(s));
 }

References SOAP_OK, and soap_send_raw().

Referenced by soap_attribute(), soap_begin_attachments(), soap_element(), soap_element_end(), soap_element_start_end_out(), soap_outliteral(), soap_puthttphdr(), soap_pututf8(), soap_query_send_key(), soap_query_send_val(), soap_send2(), soap_send3(), and soap_wstring_out().

◆ soap_send2()

SOAP_FMAC1 int SOAP_FMAC2 soap_send2	(	struct soap *	soap,
		const char *	s1,
		const char *	s2
	)

Definition at line 962 of file stdsoap2.cpp.

 {
   if (soap_send(soap, s1))
     return soap->error;
   return soap_send(soap, s2);
 }

References soap::error, and soap_send().

◆ soap_send3()

SOAP_FMAC1 int SOAP_FMAC2 soap_send3	(	struct soap *	soap,
		const char *	s1,
		const char *	s2,
		const char *	s3
	)

Definition at line 976 of file stdsoap2.cpp.

 {
   if (soap_send(soap, s1)
    || soap_send(soap, s2))
     return soap->error;
   return soap_send(soap, s3);
 }

References soap::error, and soap_send().

Referenced by soap_putmime(), and soap_putmimehdr().

◆ soap_send_empty_response()

SOAP_FMAC1 int SOAP_FMAC2 soap_send_empty_response	(	struct soap *	soap,
		int	status
	)

Definition at line 22423 of file stdsoap2.cpp.

 {
   soap_mode m = soap->omode;
   if (!(m & SOAP_IO_UDP))
   {
     soap->count = 0;
     if ((m & SOAP_IO) == SOAP_IO_CHUNK)
       soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
     (void)soap_response(soap, httpstatuscode);
     (void)soap_end_send(soap); /* force end of sends */
     soap->error = SOAP_STOP; /* stops the server from returning another response */
     soap->omode = m;
   }
   return soap_closesock(soap);
 }

References soap::count, soap::error, soap::omode, soap_closesock(), soap_end_send(), SOAP_IO, SOAP_IO_BUFFER, SOAP_IO_CHUNK, SOAP_IO_UDP, soap_response(), and SOAP_STOP.

Referenced by http_200(), and soap_send_fault().

◆ soap_send_fault()

SOAP_FMAC1 int SOAP_FMAC2 soap_send_fault ( struct soap * soap )

Definition at line 22226 of file stdsoap2.cpp.

 {
   int status = soap->error;
   if (status == SOAP_OK || status == SOAP_STOP)
     return soap_closesock(soap);
 #ifndef WITH_NOHTTP
   if (status >= 200 && status <= 299)
     return soap_send_empty_response(soap, status);
 #endif
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending back fault struct for error code %d\n", soap->error));
   soap->keep_alive = 0; /* error: close connection later by disabling keep-alive here */
   soap_set_fault(soap);
   if (soap->error < 200 && soap->error != SOAP_FAULT)
     soap->header = NULL;
   if (status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout))
   {
     int r = 1;
 #ifndef WITH_NOIO
     if (soap->fpoll && soap->fpoll(soap))
     {
       r = 0;
     }
 #ifndef WITH_LEAN
     else if (soap_valid_socket(soap->socket))
     {
       r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_SND, 0);
       if (r > 0)
       {
         int t;
         if (!(r & SOAP_TCP_SELECT_SND)
          || ((r & SOAP_TCP_SELECT_RCV)
           && recv(soap->socket, (char*)&t, 1, MSG_PEEK) < 0))
           r = 0;
       }
     }
 #endif
 #endif
     if (r > 0)
     {
       soap->error = SOAP_OK;
       if (soap->version > 0)
       {
         soap->encodingStyle = NULL; /* no encodingStyle in Faults */
         soap_serializeheader(soap);
         soap_serializefault(soap);
         (void)soap_begin_count(soap);
         if ((soap->mode & SOAP_IO_LENGTH))
         {
           if (soap_envelope_begin_out(soap)
            || soap_putheader(soap)
            || soap_body_begin_out(soap)
            || soap_putfault(soap)
            || soap_body_end_out(soap)
            || soap_envelope_end_out(soap))
           return soap_closesock(soap);
         }
         (void)soap_end_count(soap);
         if (soap_response(soap, status)
          || soap_envelope_begin_out(soap)
          || soap_putheader(soap)
          || soap_body_begin_out(soap)
          || soap_putfault(soap)
          || soap_body_end_out(soap)
          || soap_envelope_end_out(soap)
          || soap_end_send(soap))
           return soap_closesock(soap);
       }
       else
       {
         const char *s = *soap_faultstring(soap);
         const char **d = soap_faultdetail(soap);
         (void)soap_begin_count(soap);
         if ((soap->mode & SOAP_IO_LENGTH))
           if (soap_element_begin_out(soap, "fault", 0, NULL)
            || soap_outstring(soap, "reason", 0, (char*const*)&s, NULL, 0)
            || (d && *d && soap_outliteral(soap, "detail", (char*const*)d, NULL))
            || soap_element_end_out(soap, "fault"))
             return soap_closesock(soap);
         (void)soap_end_count(soap);
         if (soap_response(soap, status)
          || soap_element_begin_out(soap, "fault", 0, NULL)
          || soap_outstring(soap, "reason", 0, (char*const*)&s, NULL, 0)
          || (d && *d && soap_outliteral(soap, "detail", (char*const*)d, NULL))
          || soap_element_end_out(soap, "fault")
          || soap_end_send(soap))
           return soap_closesock(soap);
       }
     }
   }
   soap->error = status;
   return soap_closesock(soap);
 }

References mpq::d, DBGLOG, soap::encodingStyle, soap::error, soap::fpoll, soap::header, soap::keep_alive, soap::mode, NULL, soap::recv_timeout, soap::send_timeout, soap_begin_count(), soap_body_begin_out(), soap_body_end_out(), soap_closesock(), soap_element_begin_out(), soap_element_end_out(), soap_end_count(), soap_end_send(), soap_envelope_begin_out(), soap_envelope_end_out(), SOAP_EOF, SOAP_FAULT, soap_faultdetail(), soap_faultstring(), SOAP_IO_LENGTH, SOAP_OK, soap_outliteral(), soap_outstring(), soap_putfault(), soap_putheader(), soap_response(), soap_send_empty_response(), soap_serializefault(), soap_serializeheader(), soap_set_fault(), SOAP_STOP, SOAP_TCP_SELECT_RCV, SOAP_TCP_SELECT_SND, soap_valid_socket, soap::socket, tcp_select(), TEST(), and soap::version.

Referenced by soap_begin_serve(), and soap_serve().

◆ soap_send_raw()

SOAP_FMAC1 int SOAP_FMAC2 soap_send_raw	(	struct soap *	soap,
		const char *	s,
		size_t	n
	)

Definition at line 825 of file stdsoap2.cpp.

 {
   if (!s || !n)
     return SOAP_OK;
 #ifndef WITH_LEANER
   if (soap->fpreparesend && (soap->mode & SOAP_IO) != SOAP_IO_STORE && (soap->mode & SOAP_IO_LENGTH) && (soap->error = soap->fpreparesend(soap, s, n)) != SOAP_OK)
     return soap->error;
   if (soap->ffiltersend && (soap->error = soap->ffiltersend(soap, &s, &n)) != SOAP_OK)
     return soap->error;
 #endif
   if ((soap->mode & SOAP_IO_LENGTH))
   {
     soap->count += n;
   }
   else if ((soap->mode & SOAP_IO))
   {
     size_t i = sizeof(soap->buf) - soap->bufidx;
     while (n >= i)
     {
       (void)soap_memcpy((void*)(soap->buf + soap->bufidx), i, (const void*)s, i);
       soap->bufidx = sizeof(soap->buf);
       if (soap_flush(soap))
         return soap->error;
       s += i;
       n -= i;
       i = sizeof(soap->buf);
     }
     (void)soap_memcpy((void*)(soap->buf + soap->bufidx), sizeof(soap->buf) - soap->bufidx, (const void*)s, n);
     soap->bufidx += n;
   }
   else
   {
     return soap_flush_raw(soap, s, n);
   }
   return SOAP_OK;
 }

References soap::buf, soap::bufidx, soap::count, soap::error, soap::ffiltersend, soap::fpreparesend, soap::mode, soap_flush(), soap_flush_raw(), SOAP_IO, SOAP_IO_LENGTH, SOAP_IO_STORE, soap_memcpy, and SOAP_OK.

Referenced by http_post_header(), http_send_header(), soap_attribute(), soap_element(), soap_element_end(), soap_element_start_end_out(), soap_end_attachments(), soap_envelope_end_out(), soap_putbase64(), soap_putdime(), soap_putdimefield(), soap_putdimehdr(), soap_puthex(), soap_puthttphdr(), soap_putmime(), soap_putmimehdr(), soap_pututf8(), soap_query_send_key(), soap_query_send_val(), soap_send(), soap_string_out(), and soap_wstring_out().

◆ soap_sender_fault()

SOAP_FMAC1 int SOAP_FMAC2 soap_sender_fault	(	struct soap *	soap,
		const char *	faultstring,
		const char *	faultdetailXML
	)

Definition at line 22626 of file stdsoap2.cpp.

 {
   return soap_sender_fault_subcode(soap, NULL, faultstring, faultdetailXML);
 }

References NULL, and soap_sender_fault_subcode().

Referenced by ns1__executeCommand().

◆ soap_sender_fault_subcode()

SOAP_FMAC1 int SOAP_FMAC2 soap_sender_fault_subcode	(	struct soap *	soap,
		const char *	faultsubcodeQName,
		const char *	faultstring,
		const char *	faultdetailXML
	)

Definition at line 22636 of file stdsoap2.cpp.

 {
   return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : soap->version == 1 ? "SOAP-ENV:Client" : "at source", faultsubcodeQName, faultstring, faultdetailXML);
 }

References soap_copy_fault(), and soap::version.

Referenced by soap_sender_fault().

◆ soap_serializefault()

SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault ( struct soap * soap )

Definition at line 72 of file soapC.cpp.

 {
     if (soap->fault)
         soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
 }

References soap::fault, and soap_serialize_SOAP_ENV__Fault().

Referenced by soap_send_fault().

◆ soap_serializeheader()

SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader ( struct soap * soap )

Definition at line 45 of file soapC.cpp.

 {
     if (soap->version && soap->header)
         soap_serialize_SOAP_ENV__Header(soap, soap->header);
 }

References soap::header, soap_serialize_SOAP_ENV__Header(), and soap::version.

Referenced by soap_send_fault(), and soap_serve_ns1__executeCommand().

◆ soap_serve()

SOAP_FMAC5 int SOAP_FMAC6 soap_serve ( struct soap * soap )

Definition at line 21 of file soapServer.cpp.

 {
 #ifndef WITH_FASTCGI
     soap->keep_alive = soap->max_keep_alive + 1;
 #endif
     do
     {
 #ifndef WITH_FASTCGI
         if (soap->keep_alive > 0 && soap->max_keep_alive > 0)
             soap->keep_alive--;
 #endif
         if (soap_begin_serve(soap))
         {   if (soap->error >= SOAP_STOP)
                 continue;
             return soap->error;
         }
         if ((soap_serve_request(soap) || (soap->fserveloop && soap->fserveloop(soap))) && soap->error && soap->error < SOAP_STOP)
         {
 #ifdef WITH_FASTCGI
             soap_send_fault(soap);
 #else
             return soap_send_fault(soap);
 #endif
         }
 #ifdef WITH_FASTCGI
         soap_destroy(soap);
         soap_end(soap);
     } while (1);
 #else
     } while (soap->keep_alive);
 #endif
     return SOAP_OK;
 }

References soap::error, soap::fserveloop, soap::keep_alive, soap::max_keep_alive, soap_begin_serve(), soap_destroy, soap_end(), soap_send_fault(), soap_serve_request(), and SOAP_STOP.

Referenced by process_message().

◆ soap_serve_request()

SOAP_FMAC5 int SOAP_FMAC6 soap_serve_request ( struct soap * soap )

Definition at line 56 of file soapServer.cpp.

 {
     (void)soap_peek_element(soap);
     if (!soap_match_tag(soap, soap->tag, "ns1:executeCommand"))
         return soap_serve_ns1__executeCommand(soap);
     return soap->error = SOAP_NO_METHOD;
 }

References soap::error, soap_match_tag(), SOAP_NO_METHOD, soap_peek_element(), soap_serve_ns1__executeCommand(), and soap::tag.

Referenced by soap_serve().

◆ soap_set_attr()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_attr	(	struct soap *	soap,
		const char *	name,
		const char *	value,
		int	flag
	)

Definition at line 14068 of file stdsoap2.cpp.

 {
   struct soap_attribute *tp, *tq;
   if (*name == '-')
     return SOAP_OK;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value ? value : SOAP_STR_EOS));
   tq = NULL;
   for (tp = soap->attributes; tp; tq = tp, tp = tp->next)
   {
     if (!strcmp(tp->name, name))
       break;
   }
   if (!tp)
   {
     size_t l = strlen(name);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute %s\n", name));
     if (sizeof(struct soap_attribute) + l > l && (SOAP_MAXALLOCSIZE <= 0 || sizeof(struct soap_attribute) + l <= SOAP_MAXALLOCSIZE))
       tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + l);
     if (!tp)
       return soap->error = SOAP_EOM;
     tp->ns = NULL;
 #ifndef WITH_LEAN
     if ((soap->mode & SOAP_XML_CANONICAL))
     {
       struct soap_attribute **tpp = &soap->attributes;
       const char *s = strchr(name, ':');
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inserting attribute %s for c14n\n", name));
       if (!strncmp(name, "xmlns", 5))
       {
         for (; *tpp; tpp = &(*tpp)->next)
           if (strncmp((*tpp)->name, "xmlns", 5) || strcmp((*tpp)->name + 5, name + 5) > 0)
             break;
       }
       else if (!s)
       {
         for (; *tpp; tpp = &(*tpp)->next)
           if (strncmp((*tpp)->name, "xmlns", 5) && ((*tpp)->ns || strcmp((*tpp)->name, name) > 0))
             break;
       }
       else
       {
         struct soap_nlist *np = soap_lookup_ns(soap, name, s - name);
         if (np)
         {
           tp->ns = np->ns;
         }
         else
         {
           struct soap_attribute *tq;
           for (tq = soap->attributes; tq; tq = tq->next)
           {
             if (!strncmp(tq->name, "xmlns:", 6) && !strncmp(tq->name + 6, name, s - name) && !tq->name[6 + s - name])
             {
               tp->ns = tq->ns;
               break;
             }
           }
         }
         for (; *tpp; tpp = &(*tpp)->next)
         {
           int k;
           if (strncmp((*tpp)->name, "xmlns", 5) && (*tpp)->ns && tp->ns && ((k = strcmp((*tpp)->ns, tp->ns)) > 0 || (!k && strcmp((*tpp)->name, name) > 0)))
             break;
         }
       }
       tp->next = *tpp;
       *tpp = tp;
     }
     else
 #endif
     if (tq)
     {
       tq->next = tp;
       tp->next = NULL;
     }
     else
     {
       tp->next = soap->attributes;
       soap->attributes = tp;
     }
     soap_strcpy((char*)tp->name, l + 1, name);
     tp->value = NULL;
   }
   else if (tp->visible)
   {
     return SOAP_OK;
   }
   else if (value && tp->value && tp->size <= strlen(value))
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute value of %s (free %p)\n", name, (void*)tp->value));
     SOAP_FREE(soap, tp->value);
     tp->value = NULL;
     tp->ns = NULL;
   }
   if (value)
   {
     if (!tp->value)
     {
       tp->size = strlen(value) + 1;
       if (SOAP_MAXALLOCSIZE <= 0 || tp->size <= SOAP_MAXALLOCSIZE)
         tp->value = (char*)SOAP_MALLOC(soap, tp->size);
       if (!tp->value)
         return soap->error = SOAP_EOM;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value for %s (%p)\n", tp->name, (void*)tp->value));
     }
     soap_strcpy(tp->value, tp->size, value);
     if (!strncmp(tp->name, "xmlns:", 6))
       tp->ns = tp->value;
     tp->visible = 2;
     tp->flag = (short)flag;
 #ifndef WITH_LEAN
     if (!strcmp(name, "wsu:Id"))
     {
       soap->event = SOAP_SEC_BEGIN;
       soap_strcpy(soap->id, sizeof(soap->id), value);
     }
     if ((soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_XML_CANONICAL_NA))
     {
       const char *s = strchr(name, ':');
       if (s && strchr(value, ':'))
       {
         struct soap_nlist *np = soap_lookup_ns(soap, name, s - name);
         if (np && np->ns && soap->local_namespaces)
         {
           if ((!strcmp(s + 1, "type") && !strcmp(np->ns, soap->local_namespaces[2].ns)) /* xsi:type QName */
            || ((!strcmp(s + 1, "arrayType") || !strcmp(s + 1, "itemType")) && !strcmp(np->ns, soap->local_namespaces[1].ns))) /* SOAP-ENC:arrayType and SOAP-ENC:itemType QName */
             soap_utilize_ns(soap, value, 1);
         }
       }
     }
 #endif
   }
   else
   {
     tp->visible = 1;
   }
   return SOAP_OK;
 }

References soap::attributes, DBGLOG, soap::error, soap::event, soap_attribute::flag, soap::id, mpq::l, soap::local_namespaces, soap::mode, name, soap_attribute::name, soap_attribute::next, Namespace::ns, soap_nlist::ns, soap_attribute::ns, NULL, soap_attribute::size, SOAP_EOM, SOAP_FREE, soap_lookup_ns(), SOAP_MALLOC, SOAP_MAXALLOCSIZE, SOAP_OK, SOAP_SEC_BEGIN, SOAP_STR_EOS, soap_strcpy, soap_utilize_ns(), SOAP_XML_CANONICAL, SOAP_XML_CANONICAL_NA, TEST(), soap_attribute::value, and soap_attribute::visible.

Referenced by soap_attribute(), soap_body_begin_out(), soap_element(), soap_element_start_end_out(), soap_out_SOAP_ENV__Reason(), and soap_QName2s().

◆ soap_set_dime()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_dime ( struct soap * soap )

Definition at line 20079 of file stdsoap2.cpp.

 {
   soap->omode |= SOAP_ENC_DIME;
   soap->dime.first = NULL;
   soap->dime.last = NULL;
 }

References soap::dime, soap_dime::first, soap_dime::last, NULL, soap::omode, and SOAP_ENC_DIME.

◆ soap_set_dime_attachment()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_dime_attachment	(	struct soap *	soap,
		const char *	ptr,
		size_t	size,
		const char *	type,
		const char *	id,
		unsigned short	optype,
		const char *	option
	)

Definition at line 20246 of file stdsoap2.cpp.

 {
   struct soap_multipart *content = soap_alloc_multipart(soap, &soap->dime.first, &soap->dime.last, ptr, size);
   if (!content)
     return SOAP_EOM;
   content->id = soap_strdup(soap, id);
   content->type = soap_strdup(soap, type);
   content->options = soap_dime_option(soap, optype, option);
   return SOAP_OK;
 }

References soap::dime, soap_dime::first, soap_multipart::id, soap_dime::last, soap_multipart::options, ptr(), soap_multipart::size, soap_alloc_multipart(), soap_dime_option(), SOAP_EOM, SOAP_OK, soap_strdup(), and soap_multipart::type.

◆ soap_set_embedded()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_embedded	(	struct soap *	soap,
		struct soap_plist *	pp
	)

Definition at line 10200 of file stdsoap2.cpp.

 {
   if (!pp)
     return;
   if ((soap->mode & SOAP_IO_LENGTH))
     pp->mark1 = 1;
   else
     pp->mark2 = 1;
 }

References soap_plist::mark1, soap_plist::mark2, soap::mode, and SOAP_IO_LENGTH.

Referenced by soap_element_id(), and soap_embed().

◆ soap_set_endpoint()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_endpoint	(	struct soap *	soap,
		const char *	endpoint
	)

Definition at line 21139 of file stdsoap2.cpp.

 {
   const char *s, *t;
   size_t i, n;
   soap->endpoint[0] = '\0';
   soap->host[0] = '\0';
   soap->path[0] = '/';
   soap->path[1] = '\0';
   soap->port = 80;
   if (!endpoint || !*endpoint)
     return;
 #ifdef WITH_OPENSSL
   if (!soap_tag_cmp(endpoint, "https:*"))
     soap->port = 443;
 #endif
   soap_strcpy(soap->endpoint, sizeof(soap->endpoint), endpoint);
   s = strchr(endpoint, ':');
   if (s && s[1] == '/' && s[2] == '/')
     s += 3;
   else
     s = endpoint;
 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
   t = strchr(s, '@');
   if (t && *s != ':' && *s != '@')
   {
     size_t l = t - s + 1;
     char *r = (char*)soap_malloc(soap, l);
     n = s - endpoint;
     if (r)
     {
       s = soap_decode(r, l, s, ":@");
       soap->userid = r;
       soap->passwd = SOAP_STR_EOS;
       if (*s == ':')
       {
         s++;
         if (*s != '@')
         {
           l = t - s + 1;
           r = r + strlen(r) + 1;
           s = soap_decode(r, l, s, "@");
           soap->passwd = r;
         }
       }
     }
     s++;
     soap_strcpy(soap->endpoint + n, sizeof(soap->endpoint) - n, s);
   }
 #endif
   n = strlen(s);
   if (n >= sizeof(soap->host))
     n = sizeof(soap->host) - 1;
 #ifdef WITH_IPV6
   if (s[0] == '[')
   {
     s++;
     for (i = 0; i < n; i++)
     {
       if (s[i] == ']')
       {
         s++;
         --n;
         break;
       }
       soap->host[i] = s[i];
     }
   }
   else
   {
     for (i = 0; i < n; i++)
     {
       soap->host[i] = s[i];
       if (s[i] == '/' || s[i] == ':' || s[i] == '?')
         break;
     }
   }
 #else
   for (i = 0; i < n; i++)
   {
     soap->host[i] = s[i];
     if (s[i] == '/' || s[i] == ':' || s[i] == '?')
       break;
   }
 #endif
   soap->host[i] = '\0';
   if (s[i] == ':')
   {
     soap->port = (int)soap_strtol(s + i + 1, NULL, 10);
     for (i++; i < n; i++)
       if (s[i] == '/')
         break;
   }
   if (i < n && s[i])
     soap_strcpy(soap->path, sizeof(soap->path), s + i);
   if (soap->override_host && *soap->override_host)
   {
     soap_strcpy(soap->host, sizeof(soap->host), soap->override_host);
     if (soap->override_port)
       soap->port = soap->override_port;
   }
   if (soap->userid && !soap->authrealm)
     soap->authrealm = soap->host;
 }

References soap::authrealm, soap::endpoint, soap::host, mpq::l, NULL, soap::override_host, soap::override_port, soap::passwd, soap::path, soap::port, soap_decode(), soap_malloc(), SOAP_STR_EOS, soap_strcpy, soap_strtol, soap_tag_cmp(), and soap::userid.

Referenced by soap_try_connect_command().

◆ soap_set_fault()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_fault ( struct soap * soap )

Definition at line 21965 of file stdsoap2.cpp.

 {
   const char **c;
   const char **s;
   if (soap->version == 0)
     soap_version(soap);
   c = soap_faultcode(soap);
   s = soap_faultstring(soap);
   if (soap->fseterror)
     soap->fseterror(soap, c, s);
   if (!*c)
   {
     if (soap->version == 2)
       *c = "SOAP-ENV:Sender";
     else if (soap->version == 1)
       *c = "SOAP-ENV:Client";
     else
       *c = "";
   }
   if (*s)
     return;
   if (soap->error >= SOAP_POST)
     soap->error = SOAP_HTTP_METHOD;
   switch (soap->error)
   {
 #ifndef WITH_LEAN
     case SOAP_CLI_FAULT:
       *s = "Client fault";
       break;
     case SOAP_SVR_FAULT:
       *s = "Server fault";
       break;
     case SOAP_TAG_MISMATCH:
       *s = soap_set_validation_fault(soap, "tag name or namespace mismatch", NULL);
       break;
     case SOAP_TYPE:
       if (*soap->type)
         *s = soap_set_validation_fault(soap, "type mismatch ", soap->type);
       else if (*soap->arrayType)
         *s = soap_set_validation_fault(soap, "array type mismatch", NULL);
       else
         *s = soap_set_validation_fault(soap, "invalid value", NULL);
       break;
     case SOAP_SYNTAX_ERROR:
       *s = soap_set_validation_fault(soap, "syntax error", NULL);
       break;
     case SOAP_NO_TAG:
       if (soap->version == 0 && soap->level == 0)
         *s = soap_set_validation_fault(soap, "root element expected", NULL);
       else if (soap->level == 0)
         *s = soap_set_validation_fault(soap, "SOAP message expected", NULL);
       else
         *s = soap_set_validation_fault(soap, "element tag expected", NULL);
       break;
     case SOAP_END_TAG:
       *s = soap_set_validation_fault(soap, "closing tag expected", NULL);
       break;
     case SOAP_MUSTUNDERSTAND:
       *c = "SOAP-ENV:MustUnderstand";
       (SOAP_SNPRINTF(soap->msgbuf, sizeof(soap->msgbuf), strlen(soap->tag) + 65), "The data in element '%s' must be understood but cannot be processed", soap->tag);
       *s = soap->msgbuf;
       break;
     case SOAP_VERSIONMISMATCH:
       *c = "SOAP-ENV:VersionMismatch";
       *s = "Invalid SOAP message or SOAP version mismatch";
       break;
     case SOAP_DATAENCODINGUNKNOWN:
       *c = "SOAP-ENV:DataEncodingUnknown";
       *s = "Unsupported SOAP data encoding";
       break;
     case SOAP_NAMESPACE:
       *s = soap_set_validation_fault(soap, "namespace error", NULL);
       break;
     case SOAP_USER_ERROR:
       *s = "User data access error";
       break;
     case SOAP_NO_METHOD:
       (SOAP_SNPRINTF(soap->msgbuf, sizeof(soap->msgbuf), strlen(soap->tag) + 66), "Method '%s' not implemented: method name or namespace not recognized", soap->tag);
       *s = soap->msgbuf;
       break;
     case SOAP_NO_DATA:
       *s = "Data required for operation";
       break;
     case SOAP_GET_METHOD:
       *s = "HTTP GET method not implemented";
       break;
     case SOAP_PUT_METHOD:
       *s = "HTTP PUT method not implemented";
       break;
     case SOAP_PATCH_METHOD:
       *s = "HTTP PATCH method not implemented";
       break;
     case SOAP_DEL_METHOD:
       *s = "HTTP DELETE method not implemented";
       break;
     case SOAP_HTTP_METHOD:
       *s = "HTTP method error";
       break;
     case SOAP_EOM:
       *s = "Out of memory";
       break;
     case SOAP_MOE:
       *s = "Memory overflow or memory corruption error";
       break;
     case SOAP_HDR:
       *s = "Header line too long";
       break;
     case SOAP_IOB:
       *s = "Array index out of bounds";
       break;
     case SOAP_NULL:
       *s = soap_set_validation_fault(soap, "nil not allowed", NULL);
       break;
     case SOAP_DUPLICATE_ID:
       *s = soap_set_validation_fault(soap, "multiple elements (use the SOAP_XML_TREE flag) with duplicate id ", soap->id);
       if (soap->version == 2)
         *soap_faultsubcode(soap) = "SOAP-ENC:DuplicateID";
       break;
     case SOAP_MISSING_ID:
       *s = soap_set_validation_fault(soap, "missing id for ref ", soap->id);
       if (soap->version == 2)
         *soap_faultsubcode(soap) = "SOAP-ENC:MissingID";
       break;
     case SOAP_HREF:
       *s = soap_set_validation_fault(soap, "incompatible object type id-ref ", soap->id);
       break;
     case SOAP_FAULT:
       break;
 #ifndef WITH_NOIO
     case SOAP_UDP_ERROR:
       *s = "Message too large for UDP packet";
       break;
     case SOAP_TCP_ERROR:
       *s = tcp_error(soap);
       break;
 #endif
     case SOAP_HTTP_ERROR:
       *s = "An HTTP processing error occurred";
       break;
     case SOAP_NTLM_ERROR:
       *s = "An HTTP NTLM authentication error occurred";
       break;
     case SOAP_SSL_ERROR:
 #ifdef WITH_OPENSSL
       *s = "SSL/TLS error";
 #else
       *s = "OpenSSL not installed: recompile with -DWITH_OPENSSL";
 #endif
       break;
     case SOAP_PLUGIN_ERROR:
       *s = "Plugin registry error";
       break;
     case SOAP_DIME_ERROR:
       *s = "DIME format error or max DIME size exceeds SOAP_MAXDIMESIZE currently set to " SOAP_XSTRINGIFY(SOAP_MAXDIMESIZE);
       break;
     case SOAP_DIME_HREF:
       *s = "DIME href to missing attachment";
       break;
     case SOAP_DIME_MISMATCH:
       *s = "DIME version/transmission error";
       break;
     case SOAP_DIME_END:
       *s = "End of DIME error";
       break;
     case SOAP_MIME_ERROR:
       *s = "MIME format error";
       break;
     case SOAP_MIME_HREF:
       *s = "MIME href to missing attachment";
       break;
     case SOAP_MIME_END:
       *s = "End of MIME error";
       break;
     case SOAP_ZLIB_ERROR:
 #ifdef WITH_ZLIB
       (SOAP_SNPRINTF(soap->msgbuf, sizeof(soap->msgbuf), (soap->d_stream && soap->d_stream->msg ? strlen(soap->d_stream->msg) : 0) + 19), "Zlib/gzip error: '%s'", soap->d_stream && soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS);
       *s = soap->msgbuf;
 #else
       *s = "Zlib/gzip not installed for (de)compression: recompile with -DWITH_GZIP";
 #endif
       break;
     case SOAP_REQUIRED:
       *s = soap_set_validation_fault(soap, "missing required attribute", NULL);
       break;
     case SOAP_PROHIBITED:
       *s = soap_set_validation_fault(soap, "prohibited attribute present", NULL);
       break;
     case SOAP_LEVEL:
       *s = "Maximum XML nesting depth level exceeded: increase maxlevel";
       break;
     case SOAP_LENGTH:
       *s = soap_set_validation_fault(soap, "value range or content length violation", NULL);
       break;
     case SOAP_OCCURS:
       *s = soap_set_validation_fault(soap, "occurrence constraint violation", NULL);
       break;
     case SOAP_FIXED:
       *s = soap_set_validation_fault(soap, "value does not match the fixed value required", NULL);
       break;
     case SOAP_EMPTY:
       *s = soap_set_validation_fault(soap, "empty value provided where a value is required", NULL);
       break;
     case SOAP_FD_EXCEEDED:
       *s = "Maximum number of open connections was reached: increase FD_SETSIZE or define HAVE_POLL";
       break;
     case SOAP_UTF_ERROR:
       *s = "UTF content encoding error";
       break;
     case SOAP_STOP:
       *s = "Stopped: service request already handled by plugin (informative)";
       break;
 #endif
     case SOAP_EOF:
 #ifndef WITH_NOIO
       *s = soap_strerror(soap); /* *s = soap->msgbuf */
 #ifndef WITH_LEAN
       if (strlen(soap->msgbuf) + 25 < sizeof(soap->msgbuf))
       {
         (void)soap_memmove((void*)(soap->msgbuf + 25), sizeof(soap->tmpbuf) - 25, (const void*)soap->msgbuf, strlen(soap->msgbuf) + 1);
         if (soap->is)
 #if defined(__cplusplus) && !defined(WITH_COMPAT)
           (void)soap_memcpy((void*)soap->msgbuf, sizeof(soap->msgbuf), (const void*)"End or bad std::istream: ", 25);
 #else
           (void)soap_memcpy((void*)soap->msgbuf, sizeof(soap->msgbuf), (const void*)"End at NUL buffer input: ", 25);
 #endif
         else
           (void)soap_memcpy((void*)soap->msgbuf, sizeof(soap->msgbuf), (const void*)"End of file or no input: ", 25);
       }
 #endif
       break;
 #else
       *s = "End of file or no input";
       break;
 #endif
     case SOAP_ERR:
       *s = "An unspecified error occurred";
       break;
     default:
 #ifndef WITH_NOHTTP
 #ifndef WITH_LEAN
       if (soap->error >= 200 && soap->error < 600)
       {
         const char *t = http_error(soap, soap->error);
         (SOAP_SNPRINTF(soap->msgbuf, sizeof(soap->msgbuf), strlen(t) + 54), "Error %d: HTTP %d %s", soap->error, soap->error, t);
         *s = soap->msgbuf;
       }
       else
 #endif
 #endif
       {
         (SOAP_SNPRINTF(soap->msgbuf, sizeof(soap->msgbuf), 26), "Error %d", soap->error);
         *s = soap->msgbuf;
       }
     }
 }

References soap::arrayType, mpq::c, soap::d_stream, soap::error, soap::fseterror, http_error(), soap::id, soap::is, soap::level, soap::msgbuf, NULL, SOAP_CLI_FAULT, SOAP_DATAENCODINGUNKNOWN, SOAP_DEL_METHOD, SOAP_DIME_END, SOAP_DIME_ERROR, SOAP_DIME_HREF, SOAP_DIME_MISMATCH, SOAP_DUPLICATE_ID, SOAP_EMPTY, SOAP_END_TAG, SOAP_EOF, SOAP_EOM, SOAP_ERR, SOAP_FAULT, soap_faultcode(), soap_faultstring(), soap_faultsubcode(), SOAP_FD_EXCEEDED, SOAP_FIXED, SOAP_GET_METHOD, SOAP_HDR, SOAP_HREF, SOAP_HTTP_ERROR, SOAP_HTTP_METHOD, SOAP_IOB, SOAP_LENGTH, SOAP_LEVEL, SOAP_MAXDIMESIZE, soap_memcpy, soap_memmove, SOAP_MIME_END, SOAP_MIME_ERROR, SOAP_MIME_HREF, SOAP_MISSING_ID, SOAP_MOE, SOAP_MUSTUNDERSTAND, SOAP_NAMESPACE, SOAP_NO_DATA, SOAP_NO_METHOD, SOAP_NO_TAG, SOAP_NTLM_ERROR, SOAP_NULL, SOAP_OCCURS, SOAP_PATCH_METHOD, SOAP_PLUGIN_ERROR, SOAP_POST, SOAP_PROHIBITED, SOAP_PUT_METHOD, SOAP_REQUIRED, soap_set_validation_fault(), SOAP_SNPRINTF, SOAP_SSL_ERROR, SOAP_STOP, SOAP_STR_EOS, soap_strerror(), SOAP_SVR_FAULT, SOAP_SYNTAX_ERROR, SOAP_TAG_MISMATCH, SOAP_TCP_ERROR, SOAP_TYPE, SOAP_UDP_ERROR, SOAP_USER_ERROR, SOAP_UTF_ERROR, soap_version(), SOAP_VERSIONMISMATCH, SOAP_XSTRINGIFY, SOAP_ZLIB_ERROR, soap::tag, tcp_error(), soap::tmpbuf, soap::type, and soap::version.

Referenced by soap_print_fault(), soap_recv_fault(), soap_send_fault(), and soap_sprint_fault().

◆ soap_set_local_namespaces()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_local_namespaces ( struct soap * soap )

Definition at line 12576 of file stdsoap2.cpp.

 {
   if (soap->namespaces && !soap->local_namespaces)
   {
     const struct Namespace *ns1;
     struct Namespace *ns2;
     size_t n = 1;
     for (ns1 = soap->namespaces; ns1->id; ns1++)
       n++;
     n *= sizeof(struct Namespace);
     ns2 = (struct Namespace*)SOAP_MALLOC(soap, n);
     if (ns2)
     {
       (void)soap_memcpy((void*)ns2, n, (const void*)soap->namespaces, n);
       if (ns2[0].ns)
       {
         if (!strcmp(ns2[0].ns, soap_env1))
           soap->version = 1;
         else if (!strcmp(ns2[0].ns, soap_env2))
           soap->version = 2;
       }
       soap->local_namespaces = ns2;
       for (; ns2->id; ns2++)
         ns2->out = NULL;
     }
   }
 }

References Namespace::id, if(), soap::local_namespaces, soap::namespaces, Namespace::ns, NULL, Namespace::out, soap_env1, soap_env2, SOAP_MALLOC, soap_memcpy, and soap::version.

Referenced by soap_begin_count(), soap_begin_recv(), soap_copy_context(), soap_copy_stream(), soap_init_send(), soap_set_namespaces(), and soap_set_version().

◆ soap_set_mime()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_mime	(	struct soap *	soap,
		const char *	boundary,
		const char *	start
	)

Definition at line 20093 of file stdsoap2.cpp.

 {
   soap->omode |= SOAP_ENC_MIME;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
   soap->mime.boundary = soap_strdup(soap, boundary);
   soap->mime.start = soap_strdup(soap, start);
 }

References soap_mime::boundary, soap_mime::first, soap_mime::last, soap::mime, NULL, soap::omode, SOAP_ENC_MIME, soap_strdup(), and soap_mime::start.

◆ soap_set_mime_attachment()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_mime_attachment	(	struct soap *	soap,
		const char *	ptr,
		size_t	size,
		enum soap_mime_encoding	encoding,
		const char *	type,
		const char *	id,
		const char *	location,
		const char *	description
	)

Definition at line 20264 of file stdsoap2.cpp.

 {
   struct soap_multipart *content = soap_alloc_multipart(soap, &soap->mime.first, &soap->mime.last, ptr, size);
   if (!content)
     return SOAP_EOM;
   content->id = soap_strdup(soap, id);
   content->type = soap_strdup(soap, type);
   content->encoding = encoding;
   content->location = soap_strdup(soap, location);
   content->description = soap_strdup(soap, description);
   return SOAP_OK;
 }

References soap_multipart::description, description, soap_multipart::encoding, soap_mime::first, soap_multipart::id, soap_mime::last, soap_multipart::location, soap::mime, ptr(), soap_multipart::size, soap_alloc_multipart(), SOAP_EOM, SOAP_OK, soap_strdup(), and soap_multipart::type.

Referenced by soap_getmimehdr().

◆ soap_set_namespaces()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_namespaces	(	struct soap *	soap,
		const struct Namespace *	p
	)

Definition at line 12513 of file stdsoap2.cpp.

 {
   struct Namespace *ns = soap->local_namespaces;
   struct soap_nlist *np, *nq, *nr;
   unsigned int level = soap->level;
   soap->namespaces = p;
   soap->local_namespaces = NULL;
   soap_set_local_namespaces(soap);
   /* reverse the namespace list */
   np = soap->nlist;
   soap->nlist = NULL;
   if (np)
   {
     nq = np->next;
     np->next = NULL;
     while (nq)
     {
       nr = nq->next;
       nq->next = np;
       np = nq;
       nq = nr;
     }
   }
   /* then push on new stack */
   while (np)
   {
     const char *s;
     soap->level = np->level; /* preserve element nesting level */
     s = np->ns;
     if (!s && np->index >= 0 && ns)
     {
       s = ns[np->index].out;
       if (!s)
         s = ns[np->index].ns;
     }
     if (s)
       (void)soap_push_namespace(soap, np->id, s);
     nq = np;
     np = np->next;
     SOAP_FREE(soap, nq);
   }
   if (ns)
   {
     int i;
     for (i = 0; ns[i].id; i++)
     {
       if (ns[i].out)
       {
         SOAP_FREE(soap, ns[i].out);
         ns[i].out = NULL;
       }
     }
     SOAP_FREE(soap, ns);
   }
   soap->level = level; /* restore level */
   return SOAP_OK;
 }

References soap_nlist::id, soap_nlist::index, soap_nlist::level, soap::level, soap::local_namespaces, soap::namespaces, soap_nlist::next, soap::nlist, Namespace::ns, soap_nlist::ns, NULL, SOAP_FREE, SOAP_OK, soap_push_namespace(), and soap_set_local_namespaces().

◆ soap_set_receiver_error()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_receiver_error	(	struct soap *	soap,
		const char *	faultstring,
		const char *	faultdetailXML,
		int	soaperror
	)

Definition at line 22600 of file stdsoap2.cpp.

 {
   return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : soap->version == 1 ? "SOAP-ENV:Server" : "detected", NULL, faultstring, faultdetailXML, soaperror);
 }

References NULL, soap_set_error(), and soap::version.

Referenced by soap_accept(), soap_begin_recv(), soap_bind(), soap_poll(), soap_ready(), and tcp_connect().

◆ soap_set_recv_logfile()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_recv_logfile	(	struct soap *	soap,
		const char *	logfile
	)

Definition at line 11664 of file stdsoap2.cpp.

 {
   (void)soap; (void)logfile;
 #ifdef SOAP_DEBUG
   soap_set_logfile(soap, SOAP_INDEX_RECV, logfile);
 #endif
 }

References SOAP_INDEX_RECV.

Referenced by soap_copy(), soap_copy_context(), and soap_init().

◆ soap_set_sender_error()

SOAP_FMAC1 int SOAP_FMAC2 soap_set_sender_error	(	struct soap *	soap,
		const char *	faultstring,
		const char *	faultdetailXML,
		int	soaperror
	)

Definition at line 22590 of file stdsoap2.cpp.

 {
   return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : soap->version == 1 ? "SOAP-ENV:Client" : "at sender", NULL, faultstring, faultdetailXML, soaperror);
 }

References NULL, soap_set_error(), and soap::version.

Referenced by tcp_connect().

◆ soap_set_sent_logfile()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_sent_logfile	(	struct soap *	soap,
		const char *	logfile
	)

Definition at line 11677 of file stdsoap2.cpp.

 {
   (void)soap; (void)logfile;
 #ifdef SOAP_DEBUG
   soap_set_logfile(soap, SOAP_INDEX_SENT, logfile);
 #endif
 }

References SOAP_INDEX_SENT.

Referenced by soap_copy(), soap_copy_context(), and soap_init().

◆ soap_set_test_logfile()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_test_logfile	(	struct soap *	soap,
		const char *	logfile
	)

Definition at line 11690 of file stdsoap2.cpp.

 {
   (void)soap; (void)logfile;
 #ifdef SOAP_DEBUG
   soap_set_logfile(soap, SOAP_INDEX_TEST, logfile);
 #endif
 }

References SOAP_INDEX_TEST.

Referenced by soap_copy(), soap_copy_context(), and soap_init().

◆ soap_set_version()

SOAP_FMAC1 void SOAP_FMAC2 soap_set_version	(	struct soap *	soap,
		short	version
	)

Definition at line 12450 of file stdsoap2.cpp.

 {
   soap_set_local_namespaces(soap);
   if (soap->version != version && soap->local_namespaces && soap->local_namespaces[0].id && soap->local_namespaces[1].id)
   {
     if (version == 1)
     {
       soap->local_namespaces[0].ns = soap_env1;
       soap->local_namespaces[1].ns = soap_enc1;
     }
     else if (version == 2)
     {
       soap->local_namespaces[0].ns = soap_env2;
       soap->local_namespaces[1].ns = soap_enc2;
     }
     soap->version = version;
   }
   if (version == 0)
     soap->encodingStyle = SOAP_STR_EOS;
   else
     soap->encodingStyle = NULL;
 }

References soap::encodingStyle, Namespace::id, soap::local_namespaces, Namespace::ns, NULL, soap_enc1, soap_enc2, soap_env1, soap_env2, soap_set_local_namespaces(), SOAP_STR_EOS, soap::version, and setup::version.

◆ soap_short2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_short2s	(	struct soap *	soap,
		short	n
	)

Definition at line 16472 of file stdsoap2.cpp.

 {
   return soap_long2s(soap, (long)n);
 }

References soap_long2s().

◆ soap_size()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_size	(	const int *	size,
		int	dim
	)

Definition at line 3435 of file stdsoap2.cpp.

 {
   int i;
   size_t n = 0;
   if (size[0] <= 0)
     return 0;
   n = (size_t)size[0];
   for (i = 1; i < dim; i++)
   {
     if (size[i] <= 0)
       return 0;
     n *= (size_t)size[i];
   }
   return (size_t)n;
 }

References soap_ilist::size.

◆ soap_size_block()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_size_block	(	struct soap *	soap,
		struct soap_blist *	b,
		size_t	n
	)

Definition at line 3218 of file stdsoap2.cpp.

 {
   if (!b)
     b = soap->blist;
   if (b->head)
   {
     b->size -= b->head->size - n;
     b->head->size = n;
   }
   return b->size;
 }

References b, and soap::blist.

Referenced by soap_gethex(), soap_http_get_body_prefix(), soap_peek_element(), soap_recv_mime_attachment(), soap_string_in(), and soap_wstring_in().

◆ soap_sprint_fault()

SOAP_FMAC1 char* SOAP_FMAC2 soap_sprint_fault	(	struct soap *	soap,
		char *	buf,
		size_t	len
	)

Definition at line 22742 of file stdsoap2.cpp.

 {
   if (soap_check_state(soap))
   {
     soap_strcpy(buf, len, "Error: soap struct not initialized");
   }
   else if (soap->error)
   {
     const char **c, *v = NULL, *s, *d;
     c = soap_faultcode(soap);
     if (!*c)
     {
       soap_set_fault(soap);
       c = soap_faultcode(soap);
     }
     if (soap->version == 2)
       v = soap_fault_subcode(soap);
     if (!v)
       v = "no subcode";
     s = soap_fault_string(soap);
     if (!s)
       s = "[no reason]";
     d = soap_fault_detail(soap);
     if (!d)
       d = "[no detail]";
     (SOAP_SNPRINTF(buf, len, strlen(*c) + strlen(v) + strlen(s) + strlen(d) + 72), "%s%d fault %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c, v, s, d);
   }
   else if (len > 0)
   {
     *buf = '\0';
   }
   return buf;
 }

References mpq::c, mpq::d, soap::error, NULL, soap_check_state, soap_fault_detail(), soap_fault_string(), soap_fault_subcode(), soap_faultcode(), soap_set_fault(), SOAP_SNPRINTF, soap_strcpy, and soap::version.

◆ soap_ssl_accept()

SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_accept ( struct soap * )

◆ soap_ssl_client_context()

SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_client_context	(	struct soap *	soap,
		unsigned short	flags,
		const char *	keyfile,
		const char *	password,
		const char *	cafile,
		const char *	capath,
		const char *	randfile
	)

◆ soap_ssl_crl()

SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_crl	(	struct soap *	,
		const char *
	)

◆ soap_ssl_error()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_ssl_error	(	struct soap *	,
		int	ret,
		int	err
	)

Referenced by tcp_connect().

◆ soap_ssl_init()

SOAP_FMAC1 void SOAP_FMAC2 soap_ssl_init ( void )

Referenced by soap_init().

◆ soap_ssl_noinit()

SOAP_FMAC1 void SOAP_FMAC2 soap_ssl_noinit ( void )

◆ soap_ssl_server_context()

SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_server_context	(	struct soap *	soap,
		unsigned short	flags,
		const char *	keyfile,
		const char *	password,
		const char *	cafile,
		const char *	capath,
		const char *	dhfile,
		const char *	randfile,
		const char *	sid
	)

◆ soap_store_lab()

SOAP_FMAC1 int SOAP_FMAC2 soap_store_lab	(	struct soap *	soap,
		const char *	s,
		size_t	n
	)

Definition at line 14383 of file stdsoap2.cpp.

 {
   soap->labidx = 0;
   return soap_append_lab(soap, s, n);
 }

References soap::labidx, and soap_append_lab().

Referenced by soap_peek_element(), and soap_QName2s().

◆ soap_strcat()

SOAP_FMAC1 void SOAP_FMAC2 soap_strcat	(	char *	buf,
		size_t	len,
		const char *	src
	)

Definition at line 13033 of file stdsoap2.cpp.

 {
   size_t k = strlen(t);
   if (k < n)
   {
     t += k;
     n -= k;
     while (--n > 0 && *s)
       *t++ = *s++;
     *t = '\0';
   }
 }

Referenced by soap_element(), soap_extend_url(), soap_extend_url_query(), soap_putoffsets(), soap_putsizesoffsets(), and soap_url_query().

◆ soap_strdup()

SOAP_FMAC1 char* SOAP_FMAC2 soap_strdup	(	struct soap *	soap,
		const char *	s
	)

Definition at line 2789 of file stdsoap2.cpp.

 {
   char *t = NULL;
   if (s)
   {
     size_t n = strlen(s) + 1;
     if (n > 0)
     {
       t = (char*)soap_malloc(soap, n);
       if (t)
       {
         (void)soap_memcpy((void*)t, n, (const void*)s, n);
         t[n - 1] = '\0';
       }
     }
   }
   return t;
 }

References NULL, soap_malloc(), and soap_memcpy.

Referenced by http_parse_header(), ns1__executeCommand(), soap_attachment(), soap_attachment_forward(), soap_attribute(), soap_collapse(), soap_copy_fault(), soap_current_namespace_att(), soap_current_namespace_tag(), soap_element(), soap_element_start_end_out(), soap_getmimehdr(), soap_http_get_body_prefix(), soap_inliteral(), soap_instring(), soap_peek_element(), soap_QName2s(), soap_s2char(), soap_s2QName(), soap_set_dime_attachment(), soap_set_mime(), soap_set_mime_attachment(), soap_string_in(), soap_string_out(), soap_try_connect_command(), and soap_value().

◆ soap_string_in()

SOAP_FMAC1 char* SOAP_FMAC2 soap_string_in	(	struct soap *	soap,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 15157 of file stdsoap2.cpp.

 {
   char *s;
   char *t = NULL;
   size_t i;
   ULONG64 l = 0;
   int n = 0, f = 0, m = 0;
   soap_wchar c;
 #if !defined(WITH_LEANER) && defined(HAVE_WCTOMB)
   char buf[MB_LEN_MAX > 8 ? MB_LEN_MAX : 8];
 #else
   char buf[8];
 #endif
   if (maxlen < 0 && soap->maxlength > 0)
     maxlen = soap->maxlength;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reading string content, flag=%d\n", flag));
   if (flag <= 0 && soap->peeked && *soap->tag)
   {
 #ifndef WITH_LEAN
     struct soap_attribute *tp;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String content includes tag '%s' and attributes\n", soap->tag));
     t = soap->tmpbuf;
     *t = '<';
     soap_strcpy(t + 1, sizeof(soap->tmpbuf) - 1, soap->tag);
     t += strlen(t);
     for (tp = soap->attributes; tp; tp = tp->next)
     {
       if (tp->visible)
       {
         size_t k = strlen(tp->name);
         if (t + k + 1 >= soap->tmpbuf + sizeof(soap->tmpbuf))
           break; /* too many or attribute values to large */
         *t++ = ' ';
         (void)soap_strncpy(t, sizeof(soap->tmpbuf) - (t - soap->tmpbuf), tp->name, k);
         t += k;
         if (tp->value)
         {
           k = strlen(tp->value);
           if (t + k + 3 >= soap->tmpbuf + sizeof(soap->tmpbuf))
             break; /* too many or attribute values to large */
           *t++ = '=';
           *t++ = '"';
           (void)soap_strncpy(t, sizeof(soap->tmpbuf) - (t - soap->tmpbuf), tp->value, k);
           t += k;
           *t++ = '"';
         }
       }
     }
     if (!soap->body)
       *t++ = '/';
     *t++ = '>';
     *t = '\0';
     t = soap->tmpbuf;
     m = (int)strlen(soap->tmpbuf);
 #endif
     if (soap->body)
       n = 1;
     f = 1;
     soap->peeked = 0;
   }
 #ifdef WITH_CDATA
   if (flag <= 0)
   {
     int state = 0;
 #ifdef WITH_FAST
     soap->labidx = 0;                   /* use look-aside buffer */
 #else
     if (soap_alloc_block(soap) == NULL)
       return NULL;
 #endif
     for (;;)
     {
 #ifdef WITH_FAST
       size_t k;
       if (soap_append_lab(soap, NULL, 0))       /* allocate more space in look-aside buffer if necessary */
         return NULL;
       s = soap->labbuf + soap->labidx;  /* space to populate */
       k = soap->lablen - soap->labidx;  /* number of bytes available */
       soap->labidx = soap->lablen;      /* claim this space */
 #else
       size_t k = SOAP_BLKLEN;
       s = (char*)soap_push_block(soap, NULL, k);
       if (!s)
         return NULL;
 #endif
       for (i = 0; i < k; i++)
       {
         if (m > 0)
         {
           *s++ = *t++;  /* copy multibyte characters */
           m--;
           continue;
         }
         c = soap_getchar(soap);
         if ((int)c == EOF)
           goto end;
         if ((c >= 0x80 || c < SOAP_AP) && state != 1)
         {
           if ((c & 0x7FFFFFFF) >= 0x80)
           {
             soap_unget(soap, c);
             c = soap_getutf8(soap);
           }
           if ((c & 0x7FFFFFFF) >= 0x80 && (flag <= 0 || (soap->mode & SOAP_C_UTFSTRING)))
           {
             c &= 0x7FFFFFFF;
             t = buf;
             if (c < 0x0800)
               *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
             else
             {
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
               if (!((c >= 0x80 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0x10FFFF)))
                 c = SOAP_UNKNOWN_UNICODE_CHAR;
 #endif
               if (c < 0x010000)
               {
                 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
               }
               else
               {
                 if (c < 0x200000)
                 {
                   *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
                 }
                 else
                 {
                   if (c < 0x04000000)
                   {
                     *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
                   }
                   else
                   {
                     *t++ = (char)(0xFC | ((c >> 30) & 0x01));
                     *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
                   }
                   *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
                 }
                 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
               }
               *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
             }
             *t++ = (char)(0x80 | (c & 0x3F));
             m = (int)(t - buf) - 1;
             t = buf;
             *s++ = *t++;
             continue;
           }
         }
         switch (state)
         {
           case 1:
             if (c == ']')
               state = 4;
             *s++ = (char)c;
             continue;
           case 2:
             if (c == '-')
               state = 6;
             *s++ = (char)c;
             continue;
           case 3:
             if (c == '?')
               state = 8;
             *s++ = (char)c;
             continue;
           /* CDATA */
           case 4:
             if (c == ']')
               state = 5;
             else
               state = 1;
             *s++ = (char)c;
             continue;
           case 5:
             if (c == '>')
               state = 0;
             else if (c != ']')
               state = 1;
             *s++ = (char)c;
             continue;
           /* comment */
           case 6:
             if (c == '-')
               state = 7;
             else
               state = 2;
             *s++ = (char)c;
             continue;
           case 7:
             if (c == '>')
               state = 0;
             else if (c != '-')
               state = 2;
             *s++ = (char)c;
             continue;
           /* PI */
           case 8:
             if (c == '>')
               state = 0;
             else if (c != '?')
               state = 3;
             *s++ = (char)c;
             continue;
         }
         switch (c)
         {
         case SOAP_TT:
           if (n == 0)
             goto end;
           n--;
           *s++ = '<';
           t = (char*)"/";
           m = 1;
           break;
         case SOAP_LT:
           if (flag == 3 || (f && n == 0))
             goto end;
           n++;
           *s++ = '<';
           break;
         case SOAP_GT:
           *s++ = '>';
           break;
         case SOAP_QT:
           *s++ = '"';
           break;
         case SOAP_AP:
           *s++ = '\'';
           break;
         case '/':
           if (n > 0)
           {
             c = soap_getchar(soap);
             if (c == '>')
               n--;
             soap_unget(soap, c);
           }
           *s++ = '/';
           break;
         case '<':
           c = soap_getchar(soap);
           if (c == '/')
           {
             if (n == 0)
             {
               c = SOAP_TT;
               goto end;
             }
             n--;
           }
           else if (c == '!')
           {
             c = soap_getchar(soap);
             if (c == '[')
             {
               do
               {
                 c = soap_getchar(soap);
               } while ((int)c != EOF && c != '[');
               if ((int)c == EOF)
                  goto end;
               t = (char*)"![CDATA[";
               m = 8;
               state = 1;
             }
             else if (c == '-')
             {
               c = soap_getchar(soap);
               if (c == '-')
                 state = 2;
               t = (char*)"!-";
               m = 2;
               soap_unget(soap, c);
             }
             else
             {
               t = (char*)"!";
               m = 1;
               soap_unget(soap, c);
             }
             *s++ = '<';
             break;
           }
           else if (c == '?')
           {
             state = 3;
           }
           else if (flag == 3 || (f && n == 0))
           {
             soap_revget1(soap);
             c = '<';
             goto end;
           }
           else
             n++;
           soap_unget(soap, c);
           *s++ = '<';
           break;
         case '>':
           *s++ = '>';
           break;
         case '"':
           *s++ = '"';
           break;
         default:
 #ifndef WITH_LEANER
 #ifdef HAVE_WCTOMB
           if ((soap->mode & SOAP_C_MBSTRING))
           {
 #if defined(WIN32) && !defined(CYGWIN) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(__BORLANDC__)
             m = 0;
             wctomb_s(&m, buf, sizeof(buf), (wchar_t)(c & 0x7FFFFFFF));
 #else
             m = wctomb(buf, (wchar_t)(c & 0x7FFFFFFF));
 #endif
             if (m >= 1 && m <= (int)MB_CUR_MAX)
             {
               t = buf;
               *s++ = *t++;
               m--;
             }
             else
             {
               *s++ = SOAP_UNKNOWN_CHAR;
               m = 0;
             }
           }
           else
 #endif
 #endif
             *s++ = (char)(c & 0xFF);
         }
         l++;
         if (maxlen >= 0 && l > (size_t)maxlen)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
           soap->error = SOAP_LENGTH;
           return NULL;
         }
       }
     }
   }
 #endif
 #ifdef WITH_FAST
   soap->labidx = 0;                     /* use look-aside buffer */
 #else
   if (soap_alloc_block(soap) == NULL)
     return NULL;
 #endif
   for (;;)
   {
 #ifdef WITH_FAST
     size_t k;
     if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */
       return NULL;
     s = soap->labbuf + soap->labidx;    /* space to populate */
     k = soap->lablen - soap->labidx;    /* number of bytes available */
     soap->labidx = soap->lablen;        /* claim this space */
 #else
     size_t k = SOAP_BLKLEN;
     s = (char*)soap_push_block(soap, NULL, k);
     if (!s)
       return NULL;
 #endif
     for (i = 0; i < k; i++)
     {
       if (m > 0)
       {
         *s++ = *t++;    /* copy multibyte characters */
         m--;
         continue;
       }
 #ifndef WITH_CDATA
       if (flag <= 0)
         c = soap_getchar(soap);
       else
 #endif
       {
         c = soap_getutf8(soap);
         if ((soap->mode & SOAP_C_UTFSTRING))
         {
           if (c >= 0x80 || (c < SOAP_AP && c >= -0x7FFFFF80))
           {
             c &= 0x7FFFFFFF;
             t = buf;
             if (c < 0x0800)
             {
               *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
             }
             else
             {
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
               if (!((c >= 0x80 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0x10FFFF)))
                 c = SOAP_UNKNOWN_UNICODE_CHAR;
 #endif
               if (c < 0x010000)
               {
                 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
               }
               else
               {
                 if (c < 0x200000)
                 {
                   *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
                 }
                 else
                 {
                   if (c < 0x04000000)
                   {
                     *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
                   }
                   else
                   {
                     *t++ = (char)(0xFC | ((c >> 30) & 0x01));
                     *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
                   }
                   *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
                 }
                 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
               }
               *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
             }
             *t++ = (char)(0x80 | (c & 0x3F));
             m = (int)(t - buf) - 1;
             t = buf;
             *s++ = *t++;
             l++;
             if (maxlen >= 0 && l > (size_t)maxlen)
             {
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
               soap->error = SOAP_LENGTH;
               return NULL;
             }
             continue;
           }
         }
       }
       switch (c)
       {
       case SOAP_TT:
         if (n == 0)
           goto end;
         n--;
         *s++ = '<';
         t = (char*)"/";
         m = 1;
         break;
       case SOAP_LT:
         if (flag == 3 || (f && n == 0))
           goto end;
         n++;
         *s++ = '<';
         break;
       case SOAP_GT:
         *s++ = '>';
         break;
       case SOAP_QT:
         *s++ = '"';
         break;
       case SOAP_AP:
         *s++ = '\'';
         break;
       case '/':
         if (n > 0)
         {
           if (flag > 0)
           {
             c = soap_get(soap);
             if (c == SOAP_GT)
               n--;
           }
           else
           {
             c = soap_getchar(soap);
             if (c == '>')
               n--;
           }
           soap_unget(soap, c);
         }
         *s++ = '/';
         break;
       case (soap_wchar)('<' | 0x80000000):
         if (flag > 0)
         {
           *s++ = '<';
         }
         else
         {
           *s++ = '&';
           t = (char*)"lt;";
           m = 3;
         }
         break;
       case (soap_wchar)('>' | 0x80000000):
         if (flag > 0)
         {
           *s++ = '>';
         }
         else
         {
           *s++ = '&';
           t = (char*)"gt;";
           m = 3;
         }
         break;
       case (soap_wchar)('&' | 0x80000000):
         if (flag > 0)
         {
           *s++ = '&';
         }
         else
         {
           *s++ = '&';
           t = (char*)"amp;";
           m = 4;
         }
         break;
       case (soap_wchar)('"' | 0x80000000):
         if (flag > 0)
         {
           *s++ = '"';
         }
         else
         {
           *s++ = '&';
           t = (char*)"quot;";
           m = 5;
         }
         break;
       case (soap_wchar)('\'' | 0x80000000):
         if (flag > 0)
         {
           *s++ = '\'';
         }
         else
         {
           *s++ = '&';
           t = (char*)"apos;";
           m = 5;
         }
         break;
       default:
         if ((int)c == EOF)
           goto end;
 #ifndef WITH_CDATA
         if (c == '<')
         {
           c = soap_getchar(soap);
           soap_unget(soap, c);
           if (c == '/')
           {
             c = SOAP_TT;
             if (n == 0)
               goto end;
             n--;
           }
           else
           {
             n++;
           }
           *s++ = '<';
         }
         else
 #endif
 #ifndef WITH_LEANER
 #ifdef HAVE_WCTOMB
         if ((soap->mode & SOAP_C_MBSTRING))
         {
 #if defined(WIN32) && !defined(CYGWIN) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(__BORLANDC__)
           m = 0;
           wctomb_s(&m, buf, sizeof(buf), (wchar_t)(c & 0x7FFFFFFF));
 #else
           m = wctomb(buf, (wchar_t)(c & 0x7FFFFFFF));
 #endif
           if (m >= 1 && m <= (int)MB_CUR_MAX)
           {
             t = buf;
             *s++ = *t++;
             m--;
           }
           else
           {
             *s++ = SOAP_UNKNOWN_CHAR;
             m = 0;
           }
         }
         else
 #endif
 #endif
           *s++ = (char)(c & 0xFF);
       }
       l++;
       if (maxlen >= 0 && l > (size_t)maxlen)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
         soap->error = SOAP_LENGTH;
         return NULL;
       }
     }
   }
 end:
   soap_unget(soap, c);
   *s = '\0';
 #ifdef WITH_FAST
   t = soap_strdup(soap, soap->labbuf);
   if (!t)
     return NULL;
 #else
   soap_size_block(soap, NULL, i + 1);
   t = soap_save_block(soap, NULL, NULL, 0);
 #endif
   if (minlen > 0 && l < (size_t)minlen)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too short: %lu chars, minlen=%ld\n", (unsigned long)l, minlen));
     soap->error = SOAP_LENGTH;
     return NULL;
   }
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom && *t)
   {
     if (flag > 0)
       soap->dom->text = t;
     else
       soap->dom->code = t;
   }
 #endif
   if (flag == 2)
   {
     if (soap_s2QName(soap, t, &t, minlen, maxlen, pattern))
       return NULL;
   }
   else if (flag >= 4 && t)
   {
     t = soap_collapse(soap, t, flag, 1);
   }
 #ifndef WITH_LEANER
   else if (pattern && soap->fsvalidate)
   {
     soap->error = soap->fsvalidate(soap, pattern, t);
     if (soap->error)
       return NULL;
   }
 #endif
   return t;
 }

References soap::attributes, soap::body, mpq::c, soap_dom_element::code, DBGLOG, soap::dom, soap::error, f(), soap_attribute::flag, soap::fsvalidate, mpq::l, soap::labbuf, soap::labidx, soap::lablen, soap::maxlength, soap::mode, soap_attribute::name, soap_attribute::next, NULL, soap::peeked, soap_alloc_block(), SOAP_AP, soap_append_lab(), SOAP_BLKLEN, SOAP_C_MBSTRING, SOAP_C_UTFSTRING, soap_collapse(), soap_get(), soap_getchar(), soap_getutf8(), SOAP_GT, SOAP_LENGTH, SOAP_LT, soap_push_block(), SOAP_QT, soap_revget1, soap_s2QName(), soap_save_block(), soap_size_block(), soap_strcpy, soap_strdup(), soap_strncpy, SOAP_TT, soap_unget, SOAP_UNKNOWN_CHAR, SOAP_XML_DOM, soap::tag, TEST(), soap_dom_element::text, soap::tmpbuf, ULONG64, soap_attribute::value, and soap_attribute::visible.

Referenced by soap_element_end_in(), soap_getbase64(), soap_gethex(), soap_ignore(), soap_inliteral(), and soap_instring().

◆ soap_string_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_string_out	(	struct soap *	soap,
		const char *	s,
		int	flag
	)

Definition at line 15054 of file stdsoap2.cpp.

 {
   const char *t;
   soap_wchar c;
   soap_wchar mask = (soap_wchar)0xFFFFFF80UL;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_strdup(soap, s);
     if (!soap->dom->text)
       return soap->error = SOAP_EOM;
     return SOAP_OK;
   }
 #endif
   if (flag == 2 || (soap->mode & SOAP_C_UTFSTRING))
     mask = 0;
   t = s;
   while ((c = *t++))
   {
     switch (c)
     {
     case 0x09:
       if (flag)
       {
         if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#x9;", 5))
           return soap->error;
         s = t;
       }
       break;
     case 0x0A:
       if (flag)
       {
         if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xA;", 5))
           return soap->error;
         s = t;
       }
       break;
     case '&':
       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&amp;", 5))
         return soap->error;
       s = t;
       break;
     case '<':
       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&lt;", 4))
         return soap->error;
       s = t;
       break;
     case '>':
       if (!flag)
       {
         if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&gt;", 4))
           return soap->error;
         s = t;
       }
       break;
     case '"':
       if (flag)
       {
         if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&quot;", 6))
           return soap->error;
         s = t;
       }
       break;
     case 0x7F:
       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#x7F;", 6))
         return soap->error;
       s = t;
       break;
     default:
 #ifndef WITH_LEANER
 #ifdef HAVE_MBTOWC
       if ((soap->mode & SOAP_C_MBSTRING))
       {
         wchar_t wc;
         int m = mbtowc(&wc, t - 1, MB_CUR_MAX);
         if (m > 0 && !((soap_wchar)wc == c && m == 1 && c < 0x80))
         {
           if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned long)wc))
             return soap->error;
           s = t += m - 1;
           continue;
         }
       }
 #endif
 #endif
 #ifndef WITH_NOSTRINGTOUTF8
       if ((c & mask) || !(c & 0xFFFFFFE0UL))
       {
         if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned char)c))
           return soap->error;
         s = t;
       }
 #endif
     }
   }
   return soap_send_raw(soap, s, t - s - 1);
 }

References mpq::c, soap::dom, soap::error, soap_attribute::flag, soap::mode, SOAP_C_MBSTRING, SOAP_C_UTFSTRING, SOAP_EOM, SOAP_OK, soap_pututf8(), soap_send_raw(), soap_strdup(), SOAP_XML_DOM, and soap_dom_element::text.

Referenced by soap_attribute(), soap_element_result(), soap_element_start_end_out(), soap_outbyte(), soap_outdateTime(), soap_outdouble(), soap_outfloat(), soap_outint(), soap_outlong(), soap_outLONG64(), soap_outshort(), soap_outstring(), soap_outULONG64(), soap_outunsignedByte(), soap_outunsignedInt(), soap_outunsignedLong(), and soap_outunsignedShort().

◆ soap_strncat()

SOAP_FMAC1 int SOAP_FMAC2 soap_strncat	(	char *	buf,
		size_t	len,
		const char *	src,
		size_t	num
	)

Definition at line 13054 of file stdsoap2.cpp.

 {
   size_t k;
   if (!t || !s)
     return 1;
   k = strlen(t);
   if (n <= k + m)
     return 1;
   t += k;
   n -= k;
   while (--n > 0 && *s)
     *t++ = *s++;
   *t = '\0';
   return 0;
 }

Referenced by http_parse(), http_parse_header(), and soap_recv_mime_attachment().

◆ soap_strtrim()

SOAP_FMAC1 char* SOAP_FMAC2 soap_strtrim	(	struct soap *	soap,
		char *	s
	)

Definition at line 2841 of file stdsoap2.cpp.

 {
   (void)soap;
   if (s)
   {
     char *t;
     while ((*s >= 9 && *s <= 13) || *s == 32)
       s++;
     t = s;
     while (*t)
       t++;
     while (--t > s && ((*t >= 9 && *t <= 13) || *t == 32))
       continue;
     t[1] = '\0';
   }
   return s;
 }

◆ soap_tag_cmp()

SOAP_FMAC1 int SOAP_FMAC2 soap_tag_cmp	(	const char *	s,
		const char *	t
	)

Definition at line 3723 of file stdsoap2.cpp.

 {
   const char *a = NULL;
   const char *b = NULL;
   for (;;)
   {
     int c1 = *s;
     int c2 = *t;
     if (!c1 || c1 == '"')
       break;
     if (c2 != '-')
     {
       if (c1 < c2)
       {
         if (c1 >= 'A' && c1 <= 'Z')
           c1 += 'a' - 'A';
       }
       else if (c1 > c2)
       {
         if (c2 >= 'A' && c2 <= 'Z')
           c2 += 'a' - 'A';
       }
       if (c2 == '*')
       {
         c2 = *++t;
         if (!c2)
           return 0;
         a = s;
         b = t;
         continue;
       }
       if (c1 != c2)
       {
         if (!a)
           return 1;
         s = ++a;
         t = b;
         continue;
       }
     }
     s++;
     t++;
   }
   if (*t == '*' && !t[1])
     return 0;
   return *t;
 }

References mpq::a, b, and NULL.

Referenced by http_parse_header(), http_post(), soap_code_int(), soap_getmimehdr(), soap_getpi(), soap_http_header_attribute(), soap_push_namespace(), soap_QName2s(), soap_s2double(), soap_s2float(), soap_set_endpoint(), and tcp_connect().

◆ soap_tagsearch()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_tagsearch	(	const char *	big,
		const char *	little
	)

Definition at line 12610 of file stdsoap2.cpp.

 {
   if (big && little)
   {
     size_t n = strlen(little);
     const char *s = big;
     while (s)
     {
       const char *t = s;
       size_t i;
       for (i = 0; i < n; i++, t++)
       {
         if (*t != little[i])
           break;
       }
       if (*t == '\0' || *t == ' ')
       {
         if (i == n || (i > 0 && little[i-1] == ':'))
           return s;
       }
       s = strchr(t, ' ');
       if (s)
         s++;
     }
   }
   return NULL;
 }

References NULL.

Referenced by soap_attribute(), soap_element(), soap_element_start_end_out(), and soap_push_ns().

◆ soap_tell()

SOAP_FMAC1 ULONG64 SOAP_FMAC2 soap_tell ( struct soap * soap )

Definition at line 2146 of file stdsoap2.cpp.

 {
   return soap->count - soap->buflen + soap->bufidx - (soap->ahead != 0);
 }

References soap::ahead, soap::bufidx, soap::buflen, and soap::count.

Referenced by soap_getdime().

◆ soap_timegm()

SOAP_FMAC1 time_t SOAP_FMAC2 soap_timegm ( struct tm * T )

Definition at line 18523 of file stdsoap2.cpp.

 {
 #if defined(HAVE_TIMEGM)
   return timegm(T);
 #else
   time_t t, g, z;
   struct tm tm;
 #ifndef HAVE_GMTIME_R
   struct tm *tp;
 #endif
   t = mktime(T);
   if (t == (time_t)-1)
     return (time_t)-1;
 #ifdef HAVE_GMTIME_R
   if (gmtime_r(&t, &tm) == SOAP_FUNC_R_ERR)
     return (time_t)-1;
 #else
   tp = gmtime(&t);
   if (!tp)
     return (time_t)-1;
   tm = *tp;
 #endif
   tm.tm_isdst = 0;
   g = mktime(&tm);
   if (g == (time_t)-1)
     return (time_t)-1;
   z = g - t;
   return t - z;
 #endif
 }

References gmtime(), detail::gmtime_r(), SOAP_FUNC_R_ERR, and G3D::z.

Referenced by soap_s2dateTime().

◆ soap_track_free()

SOAP_FMAC1 void SOAP_FMAC2 soap_track_free	(	struct soap *	,
		const char *	,
		int	,
		void *
	)

◆ soap_track_malloc()

SOAP_FMAC1 void* SOAP_FMAC2 soap_track_malloc	(	struct soap *	,
		const char *	,
		int	,
		size_t
	)

◆ soap_ULONG642s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_ULONG642s	(	struct soap *	soap,
		ULONG64	n
	)

Definition at line 17284 of file stdsoap2.cpp.

 {
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), SOAP_ULONG_FORMAT, n);
   return soap->tmpbuf;
 }

References SOAP_SNPRINTF, SOAP_ULONG_FORMAT, and soap::tmpbuf.

Referenced by soap_outULONG64().

◆ soap_unlink()

SOAP_FMAC1 int SOAP_FMAC2 soap_unlink	(	struct soap *	soap,
		const void *	p
	)

Definition at line 10800 of file stdsoap2.cpp.

 {
   char **q;
   struct soap_clist **cp;
   if (soap && p)
   {
     for (q = (char**)(void*)&soap->alist; *q; q = *(char***)q)
     {
       if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
       {
         *q = **(char***)q;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p));
 #ifdef SOAP_MEM_DEBUG
         soap_track_unlink(soap, p);
 #endif
         return SOAP_OK;         /* found and removed from dealloc chain */
       }
     }
     for (cp = &soap->clist; *cp; cp = &(*cp)->next)
     {
       if (p == (*cp)->ptr)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked class instance %p\n", p));
         q = (char**)*cp;
         *cp = (*cp)->next;
         SOAP_FREE(soap, q);
         return SOAP_OK;         /* found and removed from dealloc chain */
       }
     }
   }
   return SOAP_ERR;
 }

References soap::alist, soap::clist, DBGLOG, soap_clist::next, SOAP_ERR, SOAP_FREE, SOAP_OK, and TEST().

◆ soap_unmark()

SOAP_FMAC1 void SOAP_FMAC2 soap_unmark	(	struct soap *	soap,
		char *	mark
	)

Definition at line 13783 of file stdsoap2.cpp.

 {
   (void)soap;
   if (mark)
     *mark = 0; /* release detection */
 }

Referenced by soap_out_PointerToSOAP_ENV__Code().

◆ soap_unsignedByte2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedByte2s	(	struct soap *	soap,
		unsigned char	n
	)

Definition at line 16920 of file stdsoap2.cpp.

 {
   return soap_unsignedLong2s(soap, (unsigned long)n);
 }

References soap_unsignedLong2s().

◆ soap_unsignedInt2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedInt2s	(	struct soap *	soap,
		unsigned int	n
	)

Definition at line 17087 of file stdsoap2.cpp.

 {
   return soap_unsignedLong2s(soap, (unsigned long)n);
 }

References soap_unsignedLong2s().

◆ soap_unsignedLong2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedLong2s	(	struct soap *	soap,
		unsigned long	n
	)

Definition at line 17185 of file stdsoap2.cpp.

 {
   (SOAP_SNPRINTF(soap->tmpbuf, sizeof(soap->tmpbuf), 20), "%lu", n);
   return soap->tmpbuf;
 }

References SOAP_SNPRINTF, and soap::tmpbuf.

Referenced by soap_outunsignedByte(), soap_outunsignedInt(), soap_outunsignedLong(), soap_outunsignedShort(), soap_unsignedByte2s(), soap_unsignedInt2s(), and soap_unsignedShort2s().

◆ soap_unsignedShort2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedShort2s	(	struct soap *	soap,
		unsigned short	n
	)

Definition at line 17003 of file stdsoap2.cpp.

 {
   return soap_unsignedLong2s(soap, (unsigned long)n);
 }

References soap_unsignedLong2s().

◆ soap_update_pointers()

SOAP_FMAC1 void SOAP_FMAC2 soap_update_pointers	(	struct soap *	soap,
		const char *	dst,
		const char *	src,
		size_t	len
	)

Definition at line 2978 of file stdsoap2.cpp.

 {
   const void *start = src, *end = src + len;
 #ifndef WITH_LEANER
   struct soap_xlist *xp;
 #endif
 #ifndef WITH_NOIDREF
   if ((soap->version && !(soap->imode & SOAP_XML_TREE)) || (soap->mode & SOAP_XML_GRAPH))
   {
     int i;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update pointers %p (%lu bytes) -> %p\n", (void*)src, (unsigned long)len, (void*)dst));
     for (i = 0; i < SOAP_IDHASH; i++)
     {
       struct soap_ilist *ip;
       for (ip = soap->iht[i]; ip; ip = ip->next)
       {
         struct soap_flist *fp;
         void *p, **q;
         if (ip->shaky)
         {
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update shaky id='%s'\n", ip->id));
           if (ip->ptr && ip->ptr >= start && ip->ptr < end)
           {
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update ptr %p -> %p\n", ip->ptr, (void*)((const char*)ip->ptr + (dst-src))));
             ip->ptr = (void*)((const char*)ip->ptr + (dst-src));
           }
           for (q = &ip->link; q; q = (void**)p)
           {
             p = *q;
             if (p && p >= start && p < end)
             {
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Link update id='%s' %p -> %p\n", ip->id, p, (void*)((const char*)p + (dst-src))));
               *q = (void*)((const char*)p + (dst-src));
             }
           }
           for (q = &ip->copy; q; q = (void**)p)
           {
             p = *q;
             if (p && p >= start && p < end)
             {
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy chain update id='%s' %p -> %p\n", ip->id, p, (void*)((const char*)p + (dst-src))));
               *q = (void*)((const char*)p + (dst-src));
             }
           }
           for (fp = ip->flist; fp; fp = fp->next)
           {
             if (fp->ptr >= start && fp->ptr < end)
             {
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy list update id='%s' target type=%d %p -> %p\n", ip->id, fp->type, fp->ptr, (void*)((char*)fp->ptr + (dst-src))));
               fp->ptr = (void*)((const char*)fp->ptr + (dst-src));
             }
           }
           if (ip->smart && ip->smart >= start && ip->smart < end)
           {
             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Smart shared pointer update %p -> %p\n", ip->smart, (void*)((const char*)ip->smart + (dst-src))));
             ip->smart = (void*)((const char*)ip->smart + (dst-src));
           }
         }
       }
     }
   }
 #else
   (void)soap; (void)start; (void)end; (void)dst; (void)src;
 #endif
 #ifndef WITH_LEANER
   for (xp = soap->xlist; xp; xp = xp->next)
   {
     if (xp->ptr && (void*)xp->ptr >= start && (void*)xp->ptr < end)
     {
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update attachment id='%s' %p -> %p\n", xp->id ? xp->id : SOAP_STR_EOS, (void*)xp->ptr, (void*)((char*)xp->ptr + (dst-src))));
       xp->ptr = (unsigned char**)((char*)xp->ptr + (dst-src));
       xp->size = (int*)((char*)xp->size + (dst-src));
       xp->type = (char**)((char*)xp->type + (dst-src));
       xp->options = (char**)((char*)xp->options + (dst-src));
     }
   }
 #endif
 }

References soap_ilist::copy, DBGLOG, soap_ilist::flist, soap_xlist::id, soap_ilist::id, soap::iht, soap::imode, soap_ilist::link, soap::mode, soap_xlist::next, soap_flist::next, soap_ilist::next, soap_xlist::options, soap_xlist::ptr, soap_flist::ptr, soap_ilist::ptr, soap_ilist::shaky, soap_xlist::size, soap_ilist::smart, SOAP_IDHASH, SOAP_STR_EOS, SOAP_XML_GRAPH, SOAP_XML_TREE, TEST(), soap_xlist::type, soap_flist::type, soap::version, and soap::xlist.

Referenced by soap_save_block().

◆ soap_url_query()

SOAP_FMAC1 void SOAP_FMAC2 soap_url_query	(	struct soap *	soap,
		const char *	s,
		const char *	t
	)

Definition at line 8478 of file stdsoap2.cpp.

 {
   size_t n = strlen(s);
   if (n)
   {
     char *r = soap->msgbuf;
     size_t k = n - (s[n-1] == '=');
     while ((r = strchr(r, '{')) != NULL)
       if (!strncmp(++r, s, k) && r[k] == '}')
         break;
     if (r)
     {
       size_t m = t ? strlen(t) : 0;
       (void)soap_memmove(r + m - 1, soap->msgbuf + sizeof(soap->msgbuf) - (r + n + 1), r + k + 1, strlen(r + k + 1) + 1);
       if (m)
         (void)soap_memmove(r - 1, soap->msgbuf + sizeof(soap->msgbuf) - (r - 1), t, m);
     }
     else
     {
       soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), s);
       if (t)
       {
         int m = (int)strlen(soap->msgbuf); /* msgbuf length is max SOAP_TMPLEN or just 1024 bytes */
         (void)soap_encode_url(t, soap->msgbuf + m, (int)sizeof(soap->msgbuf) - m);
       }
       soap_strcat(soap->msgbuf, sizeof(soap->msgbuf), "&");
     }
   }
 }

References soap::msgbuf, NULL, soap_encode_url(), soap_memmove, and soap_strcat().

◆ soap_utf8len()

SOAP_FMAC1 size_t SOAP_FMAC2 soap_utf8len ( const char * s )

Definition at line 2289 of file stdsoap2.cpp.

 {
   size_t l = 0;
   while (*s)
     if ((*s++ & 0xC0) != 0x80)
       l++;
   return l;
 }

References mpq::l.

Referenced by soap_QName(), and soap_string().

◆ soap_value()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_value ( struct soap * soap )

Definition at line 19002 of file stdsoap2.cpp.

 {
   size_t i;
   soap_wchar c = 0;
   char *s = soap->tmpbuf;
   if (!soap->body)
     return SOAP_STR_EOS;
   do
   {
     c = soap_get(soap);
   } while (soap_coblank(c));
   for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++)
   {
     if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
       break;
     *s++ = (char)c;
     c = soap_get(soap);
   }
   for (s--; i > 0; i--, s--)
   {
     if (!soap_coblank((soap_wchar)*s))
       break;
   }
   s[1] = '\0';
   soap->tmpbuf[sizeof(soap->tmpbuf) - 1] = '\0'; /* appease */
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf));
   if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
   {
     soap_unget(soap, c);
   }
   else
   {
     soap->error = SOAP_LENGTH;
     return NULL;
   }
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_strdup(soap, soap->tmpbuf);
     if (!soap->dom->text)
       return NULL;
   }
 #endif
   return soap->tmpbuf; /* return non-null pointer */
 }

References soap::body, mpq::c, DBGLOG, soap::dom, soap::error, soap::mode, NULL, soap_coblank, soap_get(), SOAP_LENGTH, SOAP_LT, SOAP_STR_EOS, soap_strdup(), SOAP_TT, soap_unget, SOAP_XML_DOM, TEST(), soap_dom_element::text, and soap::tmpbuf.

Referenced by soap_inbyte(), soap_indateTime(), soap_indouble(), soap_infloat(), soap_inint(), soap_inlong(), soap_inLONG64(), soap_inshort(), soap_inULONG64(), soap_inunsignedByte(), soap_inunsignedInt(), soap_inunsignedLong(), and soap_inunsignedShort().

◆ soap_wchar2s()

SOAP_FMAC1 const char* SOAP_FMAC2 soap_wchar2s	(	struct soap *	soap,
		const wchar_t *	s
	)

Definition at line 18183 of file stdsoap2.cpp.

 {
   soap_wchar c;
   char *r, *t;
   const wchar_t *q = s;
   size_t n = 0;
   if (!s)
     return NULL;
   while ((c = *q++))
   {
     if (c > 0 && c < 0x80)
       n++;
     else
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
       n += 4;
 #else
       n += 6;
 #endif
   }
   r = t = (char*)soap_malloc(soap, n + 1);
   if (r)
   {
     /* Convert wchar to UTF8 (chars above U+10FFFF are silently converted, but should not be used) */
     while ((c = *s++))
     {
       if (c > 0 && c < 0x80)
       {
         *t++ = (char)c;
       }
       else
       {
         /* check for UTF16 encoding when wchar_t is too small to hold UCS */
         if (sizeof(wchar_t) < 4 && (c & 0xFC00) == 0xD800)
         {
           soap_wchar d = *s;
           if ((d & 0xFC00) == 0xDC00)
           {
             c = ((c - 0xD800) << 10) + (d - 0xDC00) + 0x10000;
             s++;
           }
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
           else
           {
             c = SOAP_UNKNOWN_UNICODE_CHAR; /* Malformed UTF-16 */
           }
 #endif
         }
         if (c < 0x0800)
         {
           *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
         }
         else
         {
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
           if (!((c >= 0x80 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0x10FFFF)))
             c = SOAP_UNKNOWN_UNICODE_CHAR;
 #endif
           if (c < 0x010000)
           {
             *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
           }
           else
           {
             if (c < 0x200000)
             {
               *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
             }
             else
             {
               if (c < 0x04000000)
               {
                 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
               }
               else
               {
                 *t++ = (char)(0xFC | ((c >> 30) & 0x01));
                 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
               }
               *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
             }
             *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
           }
           *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
         }
         *t++ = (char)(0x80 | (c & 0x3F));
       }
     }
     *t = '\0';
   }
   return r;
 }

References mpq::c, mpq::d, NULL, and soap_malloc().

Referenced by soap_wstring_in(), and soap_wstring_out().

◆ soap_wstrdup()

SOAP_FMAC1 wchar_t* SOAP_FMAC2 soap_wstrdup	(	struct soap *	soap,
		const wchar_t *	s
	)

Definition at line 2813 of file stdsoap2.cpp.

 {
   wchar_t *t = NULL;
   if (s)
   {
     size_t n = 0, m;
     while (s[n])
       n++;
     n++;
     m = sizeof(wchar_t) * n;
     if (n > 0)
     {
       t = (wchar_t*)soap_malloc(soap, m);
       if (t)
       {
         (void)soap_memcpy((void*)t, m, (const void*)s, m);
         t[n - 1] = L'\0';
       }
     }
   }
   return t;
 }

References NULL, soap_malloc(), and soap_memcpy.

Referenced by soap_inwliteral(), soap_inwstring(), soap_s2wchar(), and soap_wcollapse().

◆ soap_wstring_in()

SOAP_FMAC1 wchar_t* SOAP_FMAC2 soap_wstring_in	(	struct soap *	soap,
		int	flag,
		long	minlen,
		long	maxlen,
		const char *	pattern
	)

Definition at line 15899 of file stdsoap2.cpp.

 {
   wchar_t *s;
   int i, n = 0, f = 0;
   ULONG64 l = 0;
   soap_wchar c;
   char *t = NULL;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reading wide string content\n"));
   if (maxlen < 0 && soap->maxlength > 0)
     maxlen = soap->maxlength;
   if (flag <= 0 && soap->peeked && *soap->tag)
   {
 #ifndef WITH_LEAN
     struct soap_attribute *tp;
     t = soap->tmpbuf;
     *t = '<';
     soap_strcpy(t + 1, sizeof(soap->tmpbuf) - 1, soap->tag);
     t += strlen(t);
     for (tp = soap->attributes; tp; tp = tp->next)
     {
       if (tp->visible)
       {
         size_t k = strlen(tp->name);
         if (t + k + 1 >= soap->tmpbuf + sizeof(soap->tmpbuf))
           break;
         *t++ = ' ';
         (void)soap_strncpy(t, sizeof(soap->tmpbuf) - (t - soap->tmpbuf), tp->name, k);
         t += k;
         if (tp->value)
         {
           k = strlen(tp->value);
           if (t + k + 3 >= soap->tmpbuf + sizeof(soap->tmpbuf))
             break;
           *t++ = '=';
           *t++ = '"';
           (void)soap_strncpy(t, sizeof(soap->tmpbuf) - (t - soap->tmpbuf), tp->value, k);
           t += k;
           *t++ = '"';
         }
       }
     }
     if (!soap->body)
       *t++ = '/';
     *t++ = '>';
     *t = '\0';
     t = soap->tmpbuf;
 #endif
     if (soap->body)
       n = 1;
     f = 1;
     soap->peeked = 0;
   }
   if (soap_alloc_block(soap) == NULL)
     return NULL;
   for (;;)
   {
     s = (wchar_t*)soap_push_block(soap, NULL, sizeof(wchar_t)*SOAP_BLKLEN);
     if (!s)
       return NULL;
     for (i = 0; i < SOAP_BLKLEN; i++)
     {
       if (t)
       {
         *s++ = (wchar_t)*t++;
         if (!*t)
           t = NULL;
         continue;
       }
       c = soap_getutf8(soap);
       switch (c)
       {
       case SOAP_TT:
         if (n == 0)
           goto end;
         n--;
         *s++ = L'<';
         soap_unget(soap, '/');
         break;
       case SOAP_LT:
         if (flag == 3 || (f && n == 0))
           goto end;
         n++;
         *s++ = L'<';
         break;
       case SOAP_GT:
         *s++ = L'>';
         break;
       case SOAP_QT:
         *s++ = L'"';
         break;
       case SOAP_AP:
         *s++ = L'\'';
         break;
       case '/':
         if (n > 0)
         {
           c = soap_getutf8(soap);
           if (c == SOAP_GT)
             n--;
           soap_unget(soap, c);
         }
         *s++ = L'/';
         break;
       case '<':
         if (flag > 0)
         {
           *s++ = L'<';
         }
         else
         {
           *s++ = L'&';
           t = (char*)"lt;";
         }
         break;
       case '>':
         if (flag > 0)
         {
           *s++ = L'>';
         }
         else
         {
           *s++ = (wchar_t)'&';
           t = (char*)"gt;";
         }
         break;
       case '"':
         if (flag > 0)
         {
           *s++ = L'"';
         }
         else
         {
           *s++ = L'&';
           t = (char*)"quot;";
         }
         break;
       default:
         if ((int)c == EOF)
           goto end;
         /* use UTF16 encoding when wchar_t is too small to hold UCS */
         if (sizeof(wchar_t) < 4 && c > 0xFFFF)
         {
           soap_wchar c1, c2;
           c1 = 0xD800 - (0x10000 >> 10) + (c >> 10);
           c2 = 0xDC00 + (c & 0x3FF);
           c = c1;
           soap_unget(soap, c2);
         }
         *s++ = (wchar_t)(c & 0x7FFFFFFF);
       }
       l++;
       if (maxlen >= 0 && l > (size_t)maxlen)
       {
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
         soap->error = SOAP_LENGTH;
         return NULL;
       }
     }
   }
 end:
   soap_unget(soap, c);
   *s = L'\0';
   soap_size_block(soap, NULL, sizeof(wchar_t) * (i + 1));
   if (minlen > 0 && l < (size_t)minlen)
   {
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "String too short: %lu chars, minlen=%ld\n", (unsigned long)l, minlen));
     soap->error = SOAP_LENGTH;
     return NULL;
   }
   s = (wchar_t*)soap_save_block(soap, NULL, NULL, 0);
 #ifndef WITH_LEAN
   if (flag >= 4 && s)
     s = soap_wcollapse(soap, s, flag, 1);
 #endif
 #ifndef WITH_LEANER
   if (pattern && soap->fwvalidate)
   {
     soap->error = soap->fwvalidate(soap, pattern, s);
     if (soap->error)
       return NULL;
   }
 #endif
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
     soap->dom->text = soap_wchar2s(soap, s);
 #endif
   return s;
 }

References soap::attributes, soap::body, mpq::c, DBGLOG, soap::dom, soap::error, f(), soap_attribute::flag, soap::fwvalidate, mpq::l, soap::maxlength, soap::mode, soap_attribute::name, soap_attribute::next, NULL, soap::peeked, soap_alloc_block(), SOAP_AP, SOAP_BLKLEN, soap_getutf8(), SOAP_GT, SOAP_LENGTH, SOAP_LT, soap_push_block(), SOAP_QT, soap_save_block(), soap_size_block(), soap_strcpy, soap_strncpy, SOAP_TT, soap_unget, soap_wchar2s(), soap_wcollapse(), SOAP_XML_DOM, soap::tag, TEST(), soap_dom_element::text, soap::tmpbuf, ULONG64, soap_attribute::value, and soap_attribute::visible.

Referenced by soap_inwliteral(), and soap_inwstring().

◆ soap_wstring_out()

SOAP_FMAC1 int SOAP_FMAC2 soap_wstring_out	(	struct soap *	soap,
		const wchar_t *	s,
		int	flag
	)

Definition at line 15810 of file stdsoap2.cpp.

 {
   const char *t;
   char tmp;
   soap_wchar c;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
   {
     soap->dom->text = soap_wchar2s(soap, s);
     return SOAP_OK;
   }
 #endif
   while ((c = *s++))
   {
     switch (c)
     {
     case 0x09:
       if (flag)
         t = "&#x9;";
       else
         t = "\t";
       break;
     case 0x0A:
       if (flag)
         t = "&#xA;";
       else
         t = "\n";
       break;
     case '&':
       t = "&amp;";
       break;
     case '<':
       t = "&lt;";
       break;
     case '>':
       if (flag)
         t = ">";
       else
         t = "&gt;";
       break;
     case '"':
       if (flag)
         t = "&quot;";
       else
         t = "\"";
       break;
     default:
       if (c >= 0x20 && c < 0x80)
       {
         tmp = (char)c;
         if (soap_send_raw(soap, &tmp, 1))
           return soap->error;
       }
       else
       {
         /* check for UTF16 encoding when wchar_t is too small to hold UCS */
         if (sizeof(wchar_t) < 4 && (c & 0xFC00) == 0xD800)
         {
           soap_wchar d = *s;
           if ((d & 0xFC00) == 0xDC00)
           {
             c = ((c - 0xD800) << 10) + (d - 0xDC00) + 0x10000;
             s++;
           }
 #ifdef WITH_REPLACE_ILLEGAL_UTF8
           else
           {
             c = SOAP_UNKNOWN_UNICODE_CHAR; /* Malformed UTF-16 */
           }
 #endif
         }
         if (soap_pututf8(soap, (unsigned long)c))
           return soap->error;
       }
       continue;
     }
     if (soap_send(soap, t))
       return soap->error;
   }
   return SOAP_OK;
 }

References mpq::c, mpq::d, soap::dom, soap::error, soap_attribute::flag, soap::mode, SOAP_OK, soap_pututf8(), soap_send(), soap_send_raw(), soap_wchar2s(), SOAP_XML_DOM, and soap_dom_element::text.

Referenced by soap_outwstring().

◆ soap_wstrtrim()

SOAP_FMAC1 wchar_t* SOAP_FMAC2 soap_wstrtrim	(	struct soap *	soap,
		wchar_t *	s
	)

Definition at line 2864 of file stdsoap2.cpp.

 {
   (void)soap;
   if (s)
   {
     wchar_t *t;
     while ((*s >= 9 && *s <= 13) || *s == 32)
       s++;
     t = s;
     while (*t)
       t++;
     while (--t > s && ((*t >= 9 && *t <= 13) || *t == 32))
       continue;
     t[1] = L'\0';
   }
   return s;
 }

◆ soap_xop_forward()

SOAP_FMAC1 int SOAP_FMAC2 soap_xop_forward	(	struct soap *	soap,
		unsigned char **	ptr,
		int *	size,
		char **	id,
		char **	type,
		char **	options
	)

Definition at line 2713 of file stdsoap2.cpp.

 {
   /* Check MTOM xop:Include element (within hex/base64Binary) */
   /* TODO: this code to be obsoleted with new import/xop.h conventions */
   short body = soap->body; /* should save type too? */
   if (!soap_peek_element(soap))
   {
     if (!soap_element_begin_in(soap, ":Include", 0, NULL))
     {
       if (soap_attachment_forward(soap, ptr, size, id, type, options)
        || (soap->body && soap_element_end_in(soap, ":Include")))
         return soap->error;
     }
     else if (soap->error == SOAP_TAG_MISMATCH)
       soap_retry(soap);
     else
       return soap->error;
   }
   soap->body = body;
   return SOAP_OK;
 }

References soap::body, soap::error, NULL, ptr(), soap_attachment_forward(), soap_element_begin_in(), soap_element_end_in(), SOAP_OK, soap_peek_element(), soap_retry(), and SOAP_TAG_MISMATCH.

Variable Documentation

◆ namespaces

SOAP_NMAC struct Namespace namespaces[]

extern

Definition at line 130 of file ACSoap.cpp.

Referenced by soap_init().

◆ soap

struct SOAP_CMAC soap

Definition at line 1994 of file stdsoap2.h.

Referenced by soap_attribute(), soap_element(), soap_element_start_end_out(), soap_initialize(), soap_new(), and soap_peek_element().

◆ soap_base64i

const char soap_base64i[]

Definition at line 1376 of file stdsoap2.h.

◆ soap_base64o

const char soap_base64o[]

extern

Definition at line 332 of file stdsoap2.cpp.

Referenced by soap_putbase64(), soap_s2base64(), and soap_select_mime_boundary().

◆ soap_dom_attribute

struct SOAP_CMAC soap_dom_attribute

Definition at line 2107 of file stdsoap2.h.

◆ soap_dom_element

struct SOAP_CMAC soap_dom_element

Definition at line 2107 of file stdsoap2.h.

◆ soap_double_nan

const union soap_double_nan soap_double_nan

extern

Definition at line 329 of file stdsoap2.cpp.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _REENTRANT

◆ _THREAD_SAFE

◆ DBGFUN

◆ DBGFUN1

◆ DBGFUN2

◆ DBGFUN3

◆ DBGFUN4

◆ DBGHEX

◆ DBGLOG

◆ DBGMSG

◆ DBL_NAN

◆ DBL_NINFTY

◆ DBL_PINFTY

◆ FD_SETSIZE

◆ FLT_NAN

◆ FLT_NINFTY

◆ FLT_PINFTY

◆ GSOAP_VERSION

◆ HAVE_ASCTIME_R

◆ HAVE_GETHOSTBYNAME_R

◆ HAVE_GETTIMEOFDAY

◆ HAVE_GMTIME_R

◆ HAVE_LOCALE_H

◆ HAVE_LOCALTIME_R

◆ HAVE_RAND_R

◆ HAVE_SNPRINTF

◆ HAVE_SSCANF

◆ HAVE_STRERROR_R

◆ HAVE_STRRCHR

◆ HAVE_STRTOD

◆ HAVE_STRTOL

◆ HAVE_STRTOLL

◆ HAVE_STRTOUL

◆ HAVE_STRTOULL

◆ LONG64

◆ SOAP_BASEREFNAME

◆ SOAP_BEGIN_RECV

◆ SOAP_BEGIN_SEND

◆ SOAP_BINARY_BUFLEN

◆ SOAP_BLKLEN

◆ SOAP_BUFLEN

◆ SOAP_C_MBSTRING

◆ SOAP_C_NILSTRING

◆ SOAP_C_NOIOB

◆ SOAP_C_UTFSTRING

◆ soap_check_state

◆ SOAP_CHK_EOF

◆ SOAP_CLI_FAULT

◆ soap_closesocket

◆ soap_clr_imode

◆ soap_clr_mode

◆ soap_clr_omode

◆ SOAP_CMAC

◆ SOAP_CONNECT

◆ SOAP_COPY

◆ SOAP_DATAENCODINGUNKNOWN

◆ SOAP_DEL

◆ SOAP_DEL_METHOD

◆ SOAP_DELETE

◆ SOAP_DELETE_ARRAY

◆ SOAP_DELETE_UNMANAGED

◆ soap_destroy

◆ SOAP_DIME_ABSURI

◆ SOAP_DIME_CF

◆ SOAP_DIME_END

◆ SOAP_DIME_ERROR

◆ soap_dime_error_check

◆ SOAP_DIME_HREF

◆ SOAP_DIME_MB

◆ SOAP_DIME_ME

◆ SOAP_DIME_MEDIA

◆ SOAP_DIME_MISMATCH

◆ SOAP_DIME_VERSION